diff options
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/space.cpp')
| -rw-r--r-- | debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/space.cpp | 3649 |
1 files changed, 0 insertions, 3649 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/space.cpp b/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/space.cpp deleted file mode 100644 index 5383b811..00000000 --- a/debian/uncrustify-trinity/uncrustify-trinity-0.73.0/src/space.cpp +++ /dev/null @@ -1,3649 +0,0 @@ -/** - * @file space.cpp - * Adds or removes inter-chunk spaces. - * - * Informations - * "Ignore" means do not change it. - * "Add" in the context of spaces means make sure there is at least 1. - * "Add" elsewhere means make sure one is present. - * "Remove" mean remove the space/brace/newline/etc. - * "Force" in the context of spaces means ensure that there is exactly 1. - * "Force" in other contexts means the same as "add". - * - * Rmk: spaces = space + nl - * - * @author Ben Gardner - * @author Guy Maurel, 2015-2021 - * @license GPL v2+ - */ - -#include "space.h" - -#include "log_rules.h" -#include "options_for_QT.h" -#include "punctuators.h" - -#ifdef WIN32 -#include <algorithm> // to get max -#endif // ifdef WIN32 - -using namespace std; -using namespace uncrustify; - - -/** - * Decides how to change inter-chunk spacing. - * Note that the order of the if statements is VERY important. - * - * @param first The first chunk - * @param second The second chunk - * - * @return IARF_IGNORE, IARF_ADD, IARF_REMOVE or IARF_FORCE - */ -static iarf_e do_space(chunk_t *first, chunk_t *second, int &min_sp); - -/** - * Ensure to force the space between the \a first and the \a second chunks - * if the PCF_FORCE_SPACE flag is set in the \a first. - * - * @param first The first chunk - * @param second The second chunk - * @param av Av from the do_space() - * - * @return IARF_IGNORE, IARF_ADD, IARF_REMOVE or IARF_FORCE - */ -static iarf_e ensure_force_space(chunk_t *first, chunk_t *second, iarf_e av); - -//! type that stores two chunks between those no space shall occur -struct no_space_table_t -{ - c_token_t first; //! first chunk - c_token_t second; //! second chunk -}; - - -/** - * this table lists out all combos where a space MUST be present - * CT_UNKNOWN is a wildcard. - * - * TODO: some of these are no longer needed. - */ -const no_space_table_t add_space_table[] = -{ -#include "add_space_table.h" -}; - - -/** - * this table lists out all combos where a space should NOT be present - * CT_UNKNOWN is a wildcard. - * - * TODO: some of these are no longer needed. - */ -const no_space_table_t no_space_table[] = -{ - { CT_OC_AT, CT_UNKNOWN }, - { CT_INCDEC_BEFORE, CT_WORD }, - { CT_UNKNOWN, CT_INCDEC_AFTER }, - { CT_UNKNOWN, CT_LABEL_COLON }, - { CT_UNKNOWN, CT_ACCESS_COLON }, - { CT_UNKNOWN, CT_SEMICOLON }, - { CT_UNKNOWN, CT_D_TEMPLATE }, - { CT_D_TEMPLATE, CT_UNKNOWN }, - { CT_MACRO_FUNC, CT_FPAREN_OPEN }, - { CT_PAREN_OPEN, CT_UNKNOWN }, - { CT_UNKNOWN, CT_PAREN_CLOSE }, - { CT_FPAREN_OPEN, CT_UNKNOWN }, - { CT_UNKNOWN, CT_SPAREN_CLOSE }, - { CT_SPAREN_OPEN, CT_UNKNOWN }, - { CT_UNKNOWN, CT_FPAREN_CLOSE }, - { CT_UNKNOWN, CT_COMMA }, - { CT_POS, CT_UNKNOWN }, - { CT_STAR, CT_UNKNOWN }, - { CT_VBRACE_CLOSE, CT_UNKNOWN }, - { CT_VBRACE_OPEN, CT_UNKNOWN }, - { CT_UNKNOWN, CT_VBRACE_CLOSE }, - { CT_UNKNOWN, CT_VBRACE_OPEN }, - { CT_PREPROC, CT_UNKNOWN }, - { CT_PREPROC_INDENT, CT_UNKNOWN }, - { CT_NEG, CT_UNKNOWN }, - { CT_UNKNOWN, CT_SQUARE_OPEN }, - { CT_UNKNOWN, CT_SQUARE_CLOSE }, - { CT_SQUARE_OPEN, CT_UNKNOWN }, - { CT_PAREN_CLOSE, CT_WORD }, - { CT_PAREN_CLOSE, CT_FUNC_DEF }, - { CT_PAREN_CLOSE, CT_FUNC_CALL }, - { CT_PAREN_CLOSE, CT_ADDR }, - { CT_PAREN_CLOSE, CT_FPAREN_OPEN }, - { CT_OC_SEL_NAME, CT_OC_SEL_NAME }, - { CT_TYPENAME, CT_TYPE }, -}; - - -/* - * this function is called for every chunk in the input file. - * Thus it is important to keep this function efficient - */ -static iarf_e do_space(chunk_t *first, chunk_t *second, int &min_sp) -{ - LOG_FUNC_ENTRY(); - - LOG_FMT(LSPACE, "%s(%d): orig_line is %zu, orig_col is %zu, first->text() '%s', type is %s\n", - __func__, __LINE__, first->orig_line, first->orig_col, first->text(), get_token_name(first->type)); - - min_sp = 1; - - if ( chunk_is_token(first, CT_IGNORED) - || chunk_is_token(second, CT_IGNORED)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_PP_IGNORE) - && chunk_is_token(second, CT_PP_IGNORE)) - { - // Leave spacing alone between PP_IGNORE tokens as we don't want the default behavior (which is ADD). - log_rule_short("PP_IGNORE"); - return(IARF_IGNORE); - } - - if ( chunk_is_token(first, CT_PP) - || chunk_is_token(second, CT_PP)) - { - // Add or remove space around preprocessor '##' concatenation operator. - log_rule("sp_pp_concat"); - return(options::sp_pp_concat()); - } - - if (chunk_is_token(first, CT_POUND)) - { - // Add or remove space after preprocessor '#' stringify operator. - // Also affects the '#@' charizing operator. - log_rule("sp_pp_stringify"); - return(options::sp_pp_stringify()); - } - - if ( chunk_is_token(second, CT_POUND) - && second->flags.test(PCF_IN_PREPROC) - && get_chunk_parent_type(first) != CT_MACRO_FUNC) - { - // Add or remove space before preprocessor '#' stringify operator - // as in '#define x(y) L#y'. - log_rule("sp_before_pp_stringify"); - return(options::sp_before_pp_stringify()); - } - - if ( chunk_is_token(first, CT_SPACE) - || chunk_is_token(second, CT_SPACE)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(first, CT_DECLSPEC)) // Issue 1289 - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(second, CT_NEWLINE) - || chunk_is_token(second, CT_VBRACE_OPEN)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_VBRACE_OPEN) - && second->type != CT_NL_CONT - && second->type != CT_SEMICOLON) // # Issue 1158 - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if ( chunk_is_token(first, CT_VBRACE_CLOSE) - && second->type != CT_NL_CONT) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(second, CT_VSEMICOLON)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(first, CT_MACRO_FUNC)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(second, CT_NL_CONT)) - { - // Add or remove space before a backslash-newline at the end of a line. - log_rule("sp_before_nl_cont"); - return(options::sp_before_nl_cont()); - } - - if ( chunk_is_token(first, CT_D_ARRAY_COLON) - || chunk_is_token(second, CT_D_ARRAY_COLON)) - { - // (D) Add or remove around the D named array initializer ':' operator. - log_rule("sp_d_array_colon"); - return(options::sp_d_array_colon()); - } - - if ( chunk_is_token(first, CT_CASE) - && (( CharTable::IsKw1(second->str[0]) - || chunk_is_token(second, CT_NUMBER)))) - { - // Fix the spacing between 'case' and the label. Only 'ignore' and 'force' make - // sense here. - log_rule("sp_case_label"); - return(options::sp_case_label() | IARF_ADD); - } - - if (chunk_is_token(first, CT_FOR_COLON)) - { - // java - // Add or remove space after ':' in a Java/C++11 range-based 'for', - // as in 'for (Type var : expr)'. - log_rule("sp_after_for_colon"); - return(options::sp_after_for_colon()); - } - - if (chunk_is_token(second, CT_FOR_COLON)) - { - // java - // Add or remove space before ':' in a Java/C++11 range-based 'for', - // as in 'for (Type var : expr)'. - log_rule("sp_before_for_colon"); - return(options::sp_before_for_colon()); - } - - if ( chunk_is_token(first, CT_QUESTION) - && chunk_is_token(second, CT_COND_COLON)) - { - if (options::sp_cond_ternary_short() != IARF_IGNORE) - { - // In the abbreviated ternary form '(a ?: b)', add or remove space between '?' - // and ':'. - // Overrides all other sp_cond_* options. - log_rule("sp_cond_ternary_short"); - return(options::sp_cond_ternary_short()); - } - } - - if ( chunk_is_token(first, CT_QUESTION) - || chunk_is_token(second, CT_QUESTION)) - { - if ( chunk_is_token(second, CT_QUESTION) - && (options::sp_cond_question_before() != IARF_IGNORE)) - { - // Add or remove space before the '?' in 'b ? t : f'. - // Overrides sp_cond_question. - log_rule("sp_cond_question_before"); - return(options::sp_cond_question_before()); - } - - if ( chunk_is_token(first, CT_QUESTION) - && (options::sp_cond_question_after() != IARF_IGNORE)) - { - // Add or remove space after the '?' in 'b ? t : f'. - // Overrides sp_cond_question. - log_rule("sp_cond_question_after"); - return(options::sp_cond_question_after()); - } - // Issue #2596 - // Add or remove space around the '?' in 'b ? t : f'. - // replace "if (chunk_is_token(first, CT_PAREN_CLOSE) && chunk_is_token(second, CT_QUESTION))" - log_rule("sp_cond_question"); - return(options::sp_cond_question()); - } - - if ( chunk_is_token(first, CT_COND_COLON) - || chunk_is_token(second, CT_COND_COLON)) - { - if ( chunk_is_token(second, CT_COND_COLON) - && (options::sp_cond_colon_before() != IARF_IGNORE)) - { - // Add or remove space before the ':' in 'b ? t : f'. - // Overrides sp_cond_colon. - log_rule("sp_cond_colon_before"); - return(options::sp_cond_colon_before()); - } - - if ( chunk_is_token(first, CT_COND_COLON) - && (options::sp_cond_colon_after() != IARF_IGNORE)) - { - // Add or remove space after the ':' in 'b ? t : f'. - // Overrides sp_cond_colon. - log_rule("sp_cond_colon_after"); - return(options::sp_cond_colon_after()); - } - // Issue #2596 - // replace "if (chunk_is_token(first, CT_WORD) && chunk_is_token(second, CT_COND_COLON))" - // Add or remove space around the ':' in 'b ? t : f'. - log_rule("sp_cond_colon"); - return(options::sp_cond_colon()); - } - - if ( chunk_is_token(first, CT_RANGE) - || chunk_is_token(second, CT_RANGE)) - { - // (D) Add or remove space around the D '..' operator. - log_rule("sp_range"); - return(options::sp_range()); - } - - if ( chunk_is_token(first, CT_COLON) - && get_chunk_parent_type(first) == CT_SQL_EXEC) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - // Macro stuff can only return IGNORE, ADD, or FORCE - if (chunk_is_token(first, CT_MACRO)) - { - // Add or remove space between a macro name and its definition. - log_rule("sp_macro"); - iarf_e arg = options::sp_macro(); - return(arg | ((arg != IARF_IGNORE) ? IARF_ADD : IARF_IGNORE)); - } - - if ( chunk_is_token(first, CT_FPAREN_CLOSE) - && get_chunk_parent_type(first) == CT_MACRO_FUNC) - { - // Add or remove space between a macro function ')' and its definition. - log_rule("sp_macro_func"); - iarf_e arg = options::sp_macro_func(); - return(arg | ((arg != IARF_IGNORE) ? IARF_ADD : IARF_IGNORE)); - } - - if (chunk_is_token(first, CT_PREPROC)) - { - // Remove spaces, unless we are ignoring. See indent_preproc() - if (options::pp_space() == IARF_IGNORE) - { - log_rule("pp_space"); - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(second, CT_SEMICOLON)) - { - if (chunk_is_token(first, CT_VBRACE_OPEN)) - { - // Add or remove space before ';'. - log_rule("sp_before_semi"); - return(options::sp_before_semi()); - } - - if (get_chunk_parent_type(second) == CT_FOR) - { - if ( chunk_is_token(first, CT_SPAREN_OPEN) // a - || chunk_is_token(first, CT_SEMICOLON)) // b - { - // empty, ie for (;;) - // ^ is first // a - // ^ is second // a - // or - // ^ is first // b - // ^ is second // b - // Add or remove space before a semicolon of an empty part of a for statement. - log_rule("sp_before_semi_for_empty"); - return(options::sp_before_semi_for_empty()); - } - - if (options::sp_before_semi_for() != IARF_IGNORE) - { - // Add or remove space before ';' in non-empty 'for' statements. - log_rule("sp_before_semi_for"); - return(options::sp_before_semi_for()); - } - } - iarf_e arg = options::sp_before_semi(); - - if ( chunk_is_token(first, CT_VBRACE_OPEN) // Issue #2942 - && chunk_is_token(first->prev, CT_SPAREN_CLOSE) - && get_chunk_parent_type(first) != CT_WHILE_OF_DO) - { - // Add or remove space before empty statement ';' on 'if', 'for' and 'while'. - log_rule("sp_special_semi"); - arg = arg | options::sp_special_semi(); - } - else - { - // Add or remove space before ';'. - log_rule("sp_before_semi"); - } - return(arg); - } - - if ( ( chunk_is_token(second, CT_COMMENT) - || chunk_is_token(second, CT_COMMENT_CPP)) - && ( chunk_is_token(first, CT_PP_ELSE) - || chunk_is_token(first, CT_PP_ENDIF))) - { - if (options::sp_endif_cmt() != IARF_IGNORE) - { - set_chunk_type(second, CT_COMMENT_ENDIF); - // Add or remove space between #else or #endif and a trailing comment. - log_rule("sp_endif_cmt"); - return(options::sp_endif_cmt()); - } - } - - if ( (options::sp_before_tr_emb_cmt() != IARF_IGNORE) - && ( get_chunk_parent_type(second) == CT_COMMENT_END - || get_chunk_parent_type(second) == CT_COMMENT_EMBED)) - { - // Add or remove space before a trailing or embedded comment. - // Number of spaces before a trailing or embedded comment. - log_rule("sp_num_before_tr_emb_cmt"); - min_sp = options::sp_num_before_tr_emb_cmt(); - return(options::sp_before_tr_emb_cmt()); - } - - if (get_chunk_parent_type(second) == CT_COMMENT_END) - { - switch (second->orig_prev_sp) - { - case 0: - log_rule_short("orig_prev_sp-REMOVE"); - return(IARF_REMOVE); - - case 1: - log_rule_short("orig_prev_sp-FORCE"); - return(IARF_FORCE); - - default: - log_rule_short("orig_prev_sp-ADD"); - return(IARF_ADD); - } - } - - // "for (;;)" vs. "for (;; )" and "for (a;b;c)" vs. "for (a; b; c)" - if (chunk_is_token(first, CT_SEMICOLON)) - { - if (get_chunk_parent_type(first) == CT_FOR) - { - if ( (options::sp_after_semi_for_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_SPAREN_CLOSE)) - { - // Add or remove space after the final semicolon of an empty part of a for - // statement, as in 'for ( ; ; <here> )'. - log_rule("sp_after_semi_for_empty"); - return(options::sp_after_semi_for_empty()); - } - - if ( (options::sp_after_semi_for() != IARF_IGNORE) - && second->type != CT_SPAREN_CLOSE) // Issue 1324 - { - // Add or remove space after ';' in non-empty 'for' statements. - log_rule("sp_after_semi_for"); - return(options::sp_after_semi_for()); - } - } - else if ( !chunk_is_comment(second) - && second->type != CT_BRACE_CLOSE) // issue #197 - { - // Add or remove space after ';', except when followed by a comment. - log_rule("sp_after_semi"); - return(options::sp_after_semi()); - } - // Let the comment spacing rules handle this - } - - // puts a space in the rare '+-' or '-+' - if ( ( chunk_is_token(first, CT_NEG) - || chunk_is_token(first, CT_POS) - || chunk_is_token(first, CT_ARITH) - || chunk_is_token(first, CT_SHIFT)) - && ( chunk_is_token(second, CT_NEG) - || chunk_is_token(second, CT_POS) - || chunk_is_token(second, CT_ARITH) - || chunk_is_token(second, CT_SHIFT))) - { - log_rule_short("ADD"); - return(IARF_ADD); - } - - // "return(a);" vs. "return (foo_t)a + 3;" vs. "return a;" vs. "return;" - if (chunk_is_token(first, CT_RETURN)) - { - if ( chunk_is_token(second, CT_PAREN_OPEN) - && get_chunk_parent_type(second) == CT_RETURN) - { - // Add or remove space between 'return' and '('. - log_rule("sp_return_paren"); - return(options::sp_return_paren()); - } - else if ( chunk_is_token(second, CT_BRACE_OPEN) - && get_chunk_parent_type(second) == CT_BRACED_INIT_LIST) - { - // Add or remove space between 'return' and '{'. - log_rule("sp_return_brace"); - return(options::sp_return_brace()); - } - // everything else requires a space - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - // "sizeof(foo_t)" vs. "sizeof (foo_t)" - if (chunk_is_token(first, CT_SIZEOF)) - { - if (chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'sizeof' and '('. - log_rule("sp_sizeof_paren"); - return(options::sp_sizeof_paren()); - } - - if (chunk_is_token(second, CT_ELLIPSIS)) - { - // Add or remove space between 'sizeof' and '...'. - log_rule("sp_sizeof_ellipsis"); - return(options::sp_sizeof_ellipsis()); - } - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - // "decltype(foo_t)" vs. "decltype (foo_t)" - if (chunk_is_token(first, CT_DECLTYPE)) - { - if (chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'decltype' and '('. - log_rule("sp_decltype_paren"); - return(options::sp_decltype_paren()); - } - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - // handle '::' - if (chunk_is_token(first, CT_DC_MEMBER)) - { - // Add or remove space after the '::' operator. - log_rule("sp_after_dc"); - return(options::sp_after_dc()); - } - - // Issue #889 - // mapped_file_source abc((int) ::CW2A(sTemp)); - if ( chunk_is_token(first, CT_PAREN_CLOSE) - && chunk_is_token(second, CT_DC_MEMBER) - && second->next != nullptr - && second->next->type == CT_FUNC_CALL) - { - log_rule("sp_after_cast"); - return(options::sp_after_cast()); - } - - if (chunk_is_token(second, CT_DC_MEMBER)) - { - /* '::' at the start of an identifier is not member access, but global scope operator. - * Detect if previous chunk is keyword - */ - switch (first->type) - { - case CT_SBOOL: - case CT_SASSIGN: - case CT_ARITH: - case CT_SHIFT: - case CT_CASE: - case CT_CLASS: - case CT_DELETE: - case CT_FRIEND: - case CT_NAMESPACE: - case CT_NEW: - case CT_SARITH: - case CT_SCOMPARE: - case CT_OPERATOR: - case CT_ACCESS: - case CT_QUALIFIER: - case CT_RETURN: - case CT_SIZEOF: - case CT_DECLTYPE: - case CT_STRUCT: - case CT_THROW: - case CT_TYPEDEF: - case CT_TYPENAME: - case CT_UNION: - case CT_USING: - log_rule_short("FORCE"); - return(IARF_FORCE); - - default: - break; - } - - if ( ( chunk_is_token(first, CT_WORD) - || chunk_is_token(first, CT_TYPE) - || chunk_is_token(first, CT_PAREN_CLOSE) - || CharTable::IsKw1(first->str[0])) - && (strcmp(first->text(), "void") != 0)) // Issue 1249 - { - // Add or remove space before the '::' operator. - log_rule("sp_before_dc"); - return(options::sp_before_dc()); - } - } - - // "a,b" vs. "a, b" - if (chunk_is_token(first, CT_COMMA)) - { - if (get_chunk_parent_type(first) == CT_TYPE) - { - // C# multidimensional array type: ',,' vs. ', ,' or ',]' vs. ', ]' - if (chunk_is_token(second, CT_COMMA)) - { - // (C#) Add or remove space between ',' in multidimensional array type - // like 'int[,,]'. - log_rule("sp_between_mdatype_commas"); - return(options::sp_between_mdatype_commas()); - } - // (C#) Add or remove space between ',' and ']' in multidimensional array type - // like 'int[,,]'. - log_rule("sp_after_mdatype_commas"); - return(options::sp_after_mdatype_commas()); - } - - // Fix for issue #1243 - // Don't add extra space after comma immediately followed by Angle close - if (chunk_is_token(second, CT_ANGLE_CLOSE)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - // Add or remove space after ',', i.e. 'a,b' vs. 'a, b'. - log_rule("sp_after_comma"); - return(options::sp_after_comma()); - } - - // test if we are within a SIGNAL/SLOT call - if (QT_SIGNAL_SLOT_found) - { - if ( chunk_is_token(first, CT_FPAREN_CLOSE) - && ( chunk_is_token(second, CT_FPAREN_CLOSE) - || chunk_is_token(second, CT_COMMA))) - { - if (second->level == QT_SIGNAL_SLOT_level) - { - restoreValues = true; - } - } - } - - if (chunk_is_token(second, CT_COMMA)) - { - if ( chunk_is_token(first, CT_SQUARE_OPEN) - && get_chunk_parent_type(first) == CT_TYPE) - { - // Only for C#. - // (C#) Add or remove space between '[' and ',' in multidimensional array type - // like 'int[,,]'. - log_rule("sp_before_mdatype_commas"); - return(options::sp_before_mdatype_commas()); - } - - if ( options::sp_paren_comma() != IARF_IGNORE - && ( chunk_is_token(first, CT_PAREN_OPEN) - || chunk_is_token(first, CT_FPAREN_OPEN))) - { - // Add or remove space between an open parenthesis and comma, - // i.e. '(,' vs. '( ,'. - log_rule("sp_paren_comma"); - return(options::sp_paren_comma()); - } - // Add or remove space before ','. - log_rule("sp_before_comma"); - return(options::sp_before_comma()); - } - - if (chunk_is_token(second, CT_ELLIPSIS)) - { - // type followed by a ellipsis - chunk_t *tmp = first; - - if ( chunk_is_token(tmp, CT_PTR_TYPE) - || chunk_is_token(tmp, CT_BYREF)) - { - tmp = chunk_get_prev_ncnnl(tmp); - } - - if ( chunk_is_token(tmp, CT_TYPE) - || chunk_is_token(tmp, CT_QUALIFIER)) - { - // Add or remove space between a type and '...'. - log_rule("sp_type_ellipsis"); - return(options::sp_type_ellipsis()); - } - - // non-punc followed by a ellipsis - if ( !first->flags.test(PCF_PUNCTUATOR) - && (options::sp_before_ellipsis() != IARF_IGNORE)) - { - // Add or remove space before the variadic '...' when preceded by a - // non-punctuator. - log_rule("sp_before_ellipsis"); - return(options::sp_before_ellipsis()); - } - - if ( chunk_is_token(first, CT_FPAREN_CLOSE) - || chunk_is_token(first, CT_PAREN_CLOSE)) - { - // Add or remove space between ')' and '...'. - log_rule("sp_paren_ellipsis"); - return(options::sp_paren_ellipsis()); - } - - if (chunk_is_token(first, CT_TAG_COLON)) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - } - - if (chunk_is_token(first, CT_ELLIPSIS)) - { - if (CharTable::IsKw1(second->str[0])) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if ( chunk_is_token(second, CT_PAREN_OPEN) - && first->prev != nullptr - && chunk_is_token(first->prev, CT_SIZEOF)) - { - // Add or remove space between 'sizeof...' and '('. - log_rule("sp_sizeof_ellipsis_paren"); - return(options::sp_sizeof_ellipsis_paren()); - } - } - - if (chunk_is_token(first, CT_TAG_COLON)) - { - // (Pawn) Add or remove space after the tag keyword. - log_rule("sp_after_tag"); - return(options::sp_after_tag()); - } - - if (chunk_is_token(second, CT_TAG_COLON)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - // handle '~' - if (chunk_is_token(first, CT_DESTRUCTOR)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( language_is_set(LANG_OC) - && chunk_is_token(first, CT_CATCH) - && chunk_is_token(second, CT_SPAREN_OPEN) - && (options::sp_oc_catch_paren() != IARF_IGNORE)) - { - // (OC) Add or remove space between '@catch' and '(' - // in '@catch (something) { }'. If set to ignore, sp_catch_paren is used. - log_rule("sp_oc_catch_paren"); - return(options::sp_oc_catch_paren()); - } - - if ( language_is_set(LANG_OC) - && ( chunk_is_token(first, CT_PAREN_CLOSE) - || chunk_is_token(first, CT_OC_CLASS) - || chunk_is_token(first, CT_WORD)) - && chunk_is_token(second, CT_ANGLE_OPEN) - && ( get_chunk_parent_type(second) == CT_OC_PROTO_LIST - || get_chunk_parent_type(second) == CT_OC_GENERIC_SPEC) - && (options::sp_before_oc_proto_list() != IARF_IGNORE)) - { - // (OC) Add or remove space before Objective-C protocol list - // as in '@protocol Protocol<here><Protocol_A>' or '@interface MyClass : NSObject<here><MyProtocol>'. - log_rule("sp_before_oc_proto_list"); - return(options::sp_before_oc_proto_list()); - } - - if ( language_is_set(LANG_OC) - && chunk_is_token(first, CT_OC_CLASS) - && chunk_is_token(second, CT_PAREN_OPEN) - && (options::sp_oc_classname_paren() != IARF_IGNORE)) - { - // (OC) Add or remove space between class name and '(' - // in '@interface className(categoryName)<ProtocolName>:BaseClass' - log_rule("sp_oc_classname_paren"); - return(options::sp_oc_classname_paren()); - } - - if ( chunk_is_token(first, CT_CATCH) - && chunk_is_token(second, CT_SPAREN_OPEN) - && (options::sp_catch_paren() != IARF_IGNORE)) - { - // Add or remove space between 'catch' and '(' in 'catch (something) { }'. - // If set to ignore, sp_before_sparen is used. - log_rule("sp_catch_paren"); - return(options::sp_catch_paren()); - } - - if ( chunk_is_token(first, CT_D_VERSION_IF) - && chunk_is_token(second, CT_SPAREN_OPEN) - && (options::sp_version_paren() != IARF_IGNORE)) - { - // (D) Add or remove space between 'version' and '(' - // in 'version (something) { }'. If set to ignore, sp_before_sparen is used. - log_rule("sp_version_paren"); - return(options::sp_version_paren()); - } - - if ( chunk_is_token(first, CT_D_SCOPE_IF) - && chunk_is_token(second, CT_SPAREN_OPEN) - && (options::sp_scope_paren() != IARF_IGNORE)) - { - // (D) Add or remove space between 'scope' and '(' - // in 'scope (something) { }'. If set to ignore, sp_before_sparen is used. - log_rule("sp_scope_paren"); - return(options::sp_scope_paren()); - } - - if ( language_is_set(LANG_OC) - && chunk_is_token(first, CT_SYNCHRONIZED) - && chunk_is_token(second, CT_SPAREN_OPEN)) - { - // (OC) Add or remove space between '@synchronized' and the open parenthesis, - // i.e. '@synchronized(foo)' vs. '@synchronized (foo)'. - log_rule("sp_after_oc_synchronized"); - return(options::sp_after_oc_synchronized()); - } - - // "if (" vs. "if(" - if (chunk_is_token(second, CT_SPAREN_OPEN)) - { - // Add or remove space before '(' of control statements ('if', 'for', 'switch', - // 'while', etc.). - log_rule("sp_before_sparen"); - return(options::sp_before_sparen()); - } - - if ( chunk_is_token(first, CT_LAMBDA) - || chunk_is_token(second, CT_LAMBDA)) - { - // Add or remove space around assignment operator '=', '+=', etc. - log_rule("sp_assign (lambda)"); - return(options::sp_assign()); - } - - // Handle the special lambda case for C++11: - // [=](Something arg){.....} - // Add or remove space around '=' in C++11 lambda capture specifications. - // Overrides sp_assign. - if ( (options::sp_cpp_lambda_assign() != IARF_IGNORE) - && ( ( chunk_is_token(first, CT_SQUARE_OPEN) - && get_chunk_parent_type(first) == CT_CPP_LAMBDA - && chunk_is_token(second, CT_ASSIGN)) - || ( chunk_is_token(first, CT_ASSIGN) - && chunk_is_token(second, CT_SQUARE_CLOSE) - && get_chunk_parent_type(second) == CT_CPP_LAMBDA))) - { - log_rule("sp_cpp_lambda_assign"); - return(options::sp_cpp_lambda_assign()); - } - - if ( chunk_is_token(first, CT_SQUARE_CLOSE) - && get_chunk_parent_type(first) == CT_CPP_LAMBDA) - { - // Handle the special lambda case for C++11: - // [](Something arg){.....} - // Add or remove space after the capture specification of a C++11 lambda when - // an argument list is present, as in '[] <here> (int x){ ... }'. - if (chunk_is_token(second, CT_LPAREN_OPEN)) - { - log_rule("sp_cpp_lambda_square_paren"); - return(options::sp_cpp_lambda_square_paren()); - } - else if (chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space after the capture specification of a C++11 lambda with - // no argument list is present, as in '[] <here> { ... }'. - log_rule("sp_cpp_lambda_square_brace"); - return(options::sp_cpp_lambda_square_brace()); - } - } - - if (chunk_is_token(first, CT_LPAREN_OPEN)) - { - // Add or remove space after the opening parenthesis of a argument list - // of a C++11 lambda, as in '[]( <here> int x ){ ... }'. - log_rule("sp_cpp_lambda_argument_list"); - return(options::sp_cpp_lambda_argument_list()); - } - - if (chunk_is_token(first, CT_LPAREN_CLOSE)) - { - if (chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space after the argument list of a C++11 lambda, as in - // '[](int x) <here> { ... }'. - log_rule("sp_cpp_lambda_paren_brace"); - return(options::sp_cpp_lambda_paren_brace()); - } - } - - if (chunk_is_token(second, CT_LPAREN_CLOSE)) - { - // Add or remove space before the closing parenthesis of a argument list - // of a C++11 lambda, as in '[]( int x <here> ){ ... }'. - log_rule("sp_cpp_lambda_argument_list"); - return(options::sp_cpp_lambda_argument_list()); - } - - if ( chunk_is_token(first, CT_BRACE_CLOSE) - && get_chunk_parent_type(first) == CT_CPP_LAMBDA - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - // Add or remove space between a lambda body and its call operator of an - // immediately invoked lambda, as in '[]( ... ){ ... } <here> ( ... )'. - log_rule("sp_cpp_lambda_fparen"); - return(options::sp_cpp_lambda_fparen()); - } - - if ( chunk_is_token(first, CT_ENUM) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - // Add or remove space in 'NS_ENUM ('. - if (options::sp_enum_paren() != IARF_IGNORE) - { - log_rule("sp_enum_paren"); - return(options::sp_enum_paren()); - } - } - - if (chunk_is_token(second, CT_ASSIGN)) - { - if (second->flags.test(PCF_IN_ENUM)) - { - // Add or remove space before assignment '=' in enum. - // Overrides sp_enum_assign. - if (options::sp_enum_before_assign() != IARF_IGNORE) - { - log_rule("sp_enum_before_assign"); - return(options::sp_enum_before_assign()); - } - // Add or remove space around assignment '=' in enum. - log_rule("sp_enum_assign"); - return(options::sp_enum_assign()); - } - - // Add or remove space around assignment operator '=' in a prototype. - // If set to ignore, use sp_assign. - if ( (options::sp_assign_default() != IARF_IGNORE) - && get_chunk_parent_type(second) == CT_FUNC_PROTO) - { - log_rule("sp_assign_default"); - return(options::sp_assign_default()); - } - - // Add or remove space before assignment operator '=', '+=', etc. - // Overrides sp_assign. - if (options::sp_before_assign() != IARF_IGNORE) - { - log_rule("sp_before_assign"); - return(options::sp_before_assign()); - } - // Add or remove space around assignment operator '=', '+=', etc. - log_rule("sp_assign"); - return(options::sp_assign()); - } - - if (chunk_is_token(second, CT_ASSIGN_DEFAULT_ARG)) - { - // Add or remove space around assignment operator '=' in a prototype. - // If set to ignore, use sp_assign. - if ( (options::sp_assign_default() != IARF_IGNORE) - && get_chunk_parent_type(second) == CT_FUNC_PROTO) - { - log_rule("sp_assign_default"); - return(options::sp_assign_default()); - } - - // Add or remove space before assignment operator '=', '+=', etc. - // Overrides sp_assign. - if (options::sp_before_assign() != IARF_IGNORE) - { - log_rule("sp_before_assign"); - return(options::sp_before_assign()); - } - // Add or remove space around assignment operator '=', '+=', etc. - log_rule("sp_assign"); - return(options::sp_assign()); - } - - if (chunk_is_token(first, CT_ASSIGN)) - { - if (first->flags.test(PCF_IN_ENUM)) - { - // Add or remove space after assignment '=' in enum. - // Overrides sp_enum_assign. - if (options::sp_enum_after_assign() != IARF_IGNORE) - { - log_rule("sp_enum_after_assign"); - return(options::sp_enum_after_assign()); - } - // Add or remove space around assignment '=' in enum. - log_rule("sp_enum_assign"); - return(options::sp_enum_assign()); - } - - // Add or remove space around assignment operator '=' in a prototype. - // If set to ignore, use sp_assign. - if ( (options::sp_assign_default() != IARF_IGNORE) - && get_chunk_parent_type(first) == CT_FUNC_PROTO) - { - log_rule("sp_assign_default"); - return(options::sp_assign_default()); - } - - // Add or remove space after assignment operator '=', '+=', etc. - // Overrides sp_assign. - if (options::sp_after_assign() != IARF_IGNORE) - { - log_rule("sp_after_assign"); - return(options::sp_after_assign()); - } - // Add or remove space around assignment operator '=', '+=', etc. - log_rule("sp_assign"); - return(options::sp_assign()); - } - - if ( chunk_is_token(first, CT_TRAILING_RET) - || chunk_is_token(first, CT_CPP_LAMBDA_RET) - || chunk_is_token(second, CT_TRAILING_RET) - || chunk_is_token(second, CT_CPP_LAMBDA_RET)) - { - // Add or remove space around trailing return operator '->'. - log_rule("sp_trailing_return"); - return(options::sp_trailing_return()); - } - - if (chunk_is_token(first, CT_ASSIGN_DEFAULT_ARG)) - { - // Add or remove space around assignment operator '=' in a prototype. - // If set to ignore, use sp_assign. - if ( (options::sp_assign_default() != IARF_IGNORE) - && get_chunk_parent_type(first) == CT_FUNC_PROTO) - { - log_rule("sp_assign_default"); - return(options::sp_assign_default()); - } - - // Add or remove space after assignment operator '=', '+=', etc. - // Overrides sp_assign. - if (options::sp_after_assign() != IARF_IGNORE) - { - log_rule("sp_after_assign"); - return(options::sp_after_assign()); - } - // Add or remove space around assignment operator '=', '+=', etc. - log_rule("sp_assign"); - return(options::sp_assign()); - } - - if (chunk_is_token(first, CT_BIT_COLON)) - { - if ( first->flags.test(PCF_IN_ENUM) - || first->parent_type == CT_ENUM) - { - // Add or remove space around assignment ':' in enum. - log_rule("sp_enum_colon"); - return(options::sp_enum_colon()); - } - } - - if (chunk_is_token(second, CT_BIT_COLON)) - { - if ( second->flags.test(PCF_IN_ENUM) - || second->parent_type == CT_ENUM) - { - // Add or remove space around assignment ':' in enum. - log_rule("sp_enum_colon"); - return(options::sp_enum_colon()); - } - } - - if ( chunk_is_token(first, CT_OC_AVAILABLE_VALUE) - || chunk_is_token(second, CT_OC_AVAILABLE_VALUE)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - if (chunk_is_token(second, CT_OC_BLOCK_CARET)) - { - // (OC) Add or remove space before a block pointer caret, - // i.e. '^int (int arg){...}' vs. ' ^int (int arg){...}'. - log_rule("sp_before_oc_block_caret"); - return(options::sp_before_oc_block_caret()); - } - - if (chunk_is_token(first, CT_OC_BLOCK_CARET)) - { - // (OC) Add or remove space after a block pointer caret, - // i.e. '^int (int arg){...}' vs. '^ int (int arg){...}'. - log_rule("sp_after_oc_block_caret"); - return(options::sp_after_oc_block_caret()); - } - - if (chunk_is_token(second, CT_OC_MSG_FUNC)) - { - if ( (options::sp_after_oc_msg_receiver() == IARF_REMOVE) - && ( (first->type != CT_SQUARE_CLOSE) - && (first->type != CT_FPAREN_CLOSE) - && (first->type != CT_PAREN_CLOSE))) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - // (OC) Add or remove space between the receiver and selector in a message, - // as in '[receiver selector ...]'. - log_rule("sp_after_oc_msg_receiver"); - return(options::sp_after_oc_msg_receiver()); - } - - // c++17 structured bindings e.g., "auto [x, y, z]" vs. a[x, y, z]" or "auto const [x, y, z]" vs. "auto const[x, y, z]" - if ( language_is_set(LANG_CPP) - && ( chunk_is_token(first, CT_BYREF) - || chunk_is_token(first, CT_QUALIFIER) - || chunk_is_token(first, CT_TYPE)) - && chunk_is_token(second, CT_SQUARE_OPEN) - && get_chunk_parent_type(second) != CT_OC_MSG - && get_chunk_parent_type(second) != CT_CS_SQ_STMT) - { - // Add or remove space before C++17 structured bindings. - log_rule("sp_cpp_before_struct_binding"); - return(options::sp_cpp_before_struct_binding()); - } - - // "a [x]" vs. "a[x]" - if ( chunk_is_token(second, CT_SQUARE_OPEN) - && ( get_chunk_parent_type(second) != CT_OC_MSG - && get_chunk_parent_type(second) != CT_CS_SQ_STMT - && get_chunk_parent_type(second) != CT_CPP_LAMBDA)) - { - if ( second->flags.test(PCF_IN_SPAREN) - && (chunk_is_token(first, CT_IN))) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if (chunk_is_token(first, CT_ASM_COLON)) - { - // Add or remove space before '[' for asm block. - log_rule("sp_before_square_asm_block"); - return(options::sp_before_square_asm_block()); - } - - if (first->flags.test(PCF_VAR_DEF)) - { - // Add or remove space before '[' for a variable definition. - log_rule("sp_before_vardef_square"); - return(options::sp_before_vardef_square()); - } - // Add or remove space before '[' (except '[]'). - log_rule("sp_before_square"); - return(options::sp_before_square()); - } - - // "byte[]" vs. "byte []" - if (chunk_is_token(second, CT_TSQUARE)) - { - // Add or remove space before '[]'. - log_rule("sp_before_squares"); - return(options::sp_before_squares()); - } - - if ( (options::sp_angle_shift() != IARF_IGNORE) - && chunk_is_token(first, CT_ANGLE_CLOSE) - && chunk_is_token(second, CT_ANGLE_CLOSE)) - { - // Add or remove space between '>' and '>' in '>>' (template stuff). - log_rule("sp_angle_shift"); - return(options::sp_angle_shift()); - } - - // spacing around template < > stuff - if ( chunk_is_token(first, CT_ANGLE_OPEN) - || chunk_is_token(second, CT_ANGLE_CLOSE)) - { - if ( chunk_is_token(first, CT_ANGLE_OPEN) - && chunk_is_token(second, CT_ANGLE_CLOSE)) - { - // Add or remove space inside '<>'. - log_rule("sp_inside_angle_empty"); - return(options::sp_inside_angle_empty()); - } - // Add or remove space inside '<' and '>'. - log_rule("sp_inside_angle"); - iarf_e op = options::sp_inside_angle(); - - // special: if we're not supporting digraphs, then we shouldn't create them! - if ( (op == IARF_REMOVE) - && !options::enable_digraphs() - && chunk_is_token(first, CT_ANGLE_OPEN) - && chunk_is_token(second, CT_DC_MEMBER)) - { - op = IARF_IGNORE; - } - // TODO log_rule?? - return(op); - } - - if (chunk_is_token(second, CT_ANGLE_OPEN)) - { - if ( chunk_is_token(first, CT_TEMPLATE) - && (options::sp_template_angle() != IARF_IGNORE)) - { - // Add or remove space between 'template' and '<'. - // If set to ignore, sp_before_angle is used. - log_rule("sp_template_angle"); - return(options::sp_template_angle()); - } - - if (first->type != CT_QUALIFIER) - { - // Add or remove space before '<'. - log_rule("sp_before_angle"); - return(options::sp_before_angle()); - } - } - - if (chunk_is_token(first, CT_ANGLE_CLOSE)) - { - if ( chunk_is_token(second, CT_WORD) - || CharTable::IsKw1(second->str[0])) - { - // Add or remove space between '>' and a word as in 'List<byte> m;' or - // 'template <typename T> static ...'. - if (options::sp_angle_word() != IARF_IGNORE) - { - log_rule("sp_angle_word"); - return(options::sp_angle_word()); - } - } - - if ( chunk_is_token(second, CT_FPAREN_OPEN) - || chunk_is_token(second, CT_PAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Add or remove space between '>' and '()' as found in 'new List<byte>();'. - log_rule("sp_angle_paren_empty"); - return(options::sp_angle_paren_empty()); - } - // Add or remove space between '>' and '(' as found in 'new List<byte>(foo);'. - log_rule("sp_angle_paren"); - return(options::sp_angle_paren()); - } - - if (chunk_is_token(second, CT_DC_MEMBER)) - { - // Add or remove space before the '::' operator. - log_rule("sp_before_dc"); - return(options::sp_before_dc()); - } - - if ( second->type != CT_BYREF - && second->type != CT_PTR_TYPE - && second->type != CT_BRACE_OPEN - && second->type != CT_PAREN_CLOSE) - { - if ( chunk_is_token(second, CT_CLASS_COLON) - && options::sp_angle_colon() != IARF_IGNORE) - { - // Add or remove space between '>' and ':'. - log_rule("sp_angle_colon"); - return(options::sp_angle_colon()); - } - - // Whether sp_after_angle takes precedence over sp_inside_fparen. This was the - // historic behavior, but is probably not the desired behavior, so this is off - // by default. - if ( chunk_is_token(second, CT_FPAREN_CLOSE) - && options::sp_inside_fparen() != IARF_IGNORE - && !options::use_sp_after_angle_always()) - { - // Add or remove space between '>' and ')'. - log_rule("sp_inside_fparen"); - return(options::sp_inside_fparen()); - } - // Add or remove space after '>'. - log_rule("sp_after_angle"); - return(options::sp_after_angle()); - } - } - - if (chunk_is_token(first, CT_BYREF)) - { - if ( options::sp_after_byref_func() != IARF_IGNORE - && ( get_chunk_parent_type(first) == CT_FUNC_DEF - || get_chunk_parent_type(first) == CT_FUNC_PROTO)) - { - // Add or remove space after a reference sign '&', if followed by a function - // prototype or function definition. - log_rule("sp_after_byref_func"); - return(options::sp_after_byref_func()); - } - - if ( ( CharTable::IsKw1(second->str[0]) - && ( options::sp_after_byref() != IARF_IGNORE - || ( !chunk_is_token(second, CT_FUNC_PROTO) - && !chunk_is_token(second, CT_FUNC_DEF)))) - || chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space after reference sign '&', if followed by a word. - log_rule("sp_after_byref"); - return(options::sp_after_byref()); - } - } - - if ( chunk_is_token(second, CT_BYREF) - && !chunk_is_token(first, CT_PAREN_OPEN)) - { - // Add or remove space before a reference sign '&', if followed by a function - // prototype or function definition. - if (options::sp_before_byref_func() != IARF_IGNORE) - { - chunk_t *next = chunk_get_next(second); - - if ( next != nullptr - && ( get_chunk_parent_type(next) == CT_FUNC_DEF - || get_chunk_parent_type(next) == CT_FUNC_PROTO)) - { - log_rule("sp_before_byref_func"); - return(options::sp_before_byref_func()); - } - } - - // Add or remove space before a reference sign '&' that isn't followed by a - // variable name. If set to 'ignore', sp_before_byref is used instead. - if (options::sp_before_unnamed_byref() != IARF_IGNORE) - { - chunk_t *next = chunk_get_next_nc(second); - - if ( next != nullptr - && next->type != CT_WORD) - { - log_rule("sp_before_unnamed_byref"); - return(options::sp_before_unnamed_byref()); - } - } - // Add or remove space before a reference sign '&'. - log_rule("sp_before_byref"); - return(options::sp_before_byref()); - } - - if (chunk_is_token(first, CT_SPAREN_CLOSE)) - { - if (chunk_is_token(second, CT_BRACE_OPEN)) - { - if (get_chunk_parent_type(second) == CT_CATCH) - { - if ( language_is_set(LANG_OC) - && (options::sp_oc_catch_brace() != IARF_IGNORE)) - { - // (OC) Add or remove space before the '{' of a '@catch' statement, if the '{' - // and '@catch' are on the same line, as in '@catch (decl) <here> {'. - // If set to ignore, sp_catch_brace is used. - // only to help the vim command }} - log_rule("sp_oc_catch_brace"); - return(options::sp_oc_catch_brace()); - } - - if (options::sp_catch_brace() != IARF_IGNORE) - { - // Add or remove space before the '{' of a 'catch' statement, if the '{' and - // 'catch' are on the same line, as in 'catch (decl) <here> {'. - log_rule("sp_catch_brace"); - return(options::sp_catch_brace()); - } - } - - if (options::sp_sparen_brace() != IARF_IGNORE) - { - // Add or remove space between ')' and '{' of of control statements. - log_rule("sp_sparen_brace"); - return(options::sp_sparen_brace()); - } - } - - if ( !chunk_is_comment(second) - && (options::sp_after_sparen() != IARF_IGNORE)) - { - // Add or remove space after ')' of control statements. - log_rule("sp_after_sparen"); - return(options::sp_after_sparen()); - } - } - - if ( chunk_is_token(second, CT_FPAREN_OPEN) - && get_chunk_parent_type(first) == CT_OPERATOR - && (options::sp_after_operator_sym() != IARF_IGNORE)) - { - if ( (options::sp_after_operator_sym_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Overrides sp_after_operator_sym when the operator has no arguments, as in - // 'operator *()'. - log_rule("sp_after_operator_sym_empty"); - return(options::sp_after_operator_sym_empty()); - } - } - // Add or remove space between the operator symbol and the open parenthesis, as - // in 'operator ++('. - log_rule("sp_after_operator_sym"); - return(options::sp_after_operator_sym()); - } - - // Issue #2270 - // Translations under vala - if ( language_is_set(LANG_VALA) - && chunk_is_token(first, CT_FUNC_CALL)) - { - if ( chunk_is_str(first, "_", 1) - && chunk_is_token(second, CT_FPAREN_OPEN) - && (options::sp_vala_after_translation() != IARF_IGNORE)) - { - // Add or remove space after '_'. - log_rule("sp_vala_after_translation"); - return(options::sp_vala_after_translation()); - } - } - - if ( chunk_is_token(first, CT_MACRO_OPEN) - || chunk_is_token(first, CT_MACRO_CLOSE) - || chunk_is_token(first, CT_MACRO_ELSE)) - { - if (chunk_is_token(second, CT_FPAREN_OPEN)) - { - // TODO: provide some test data to check this block - // Add or remove space between function name and '(' on function calls. - log_rule("sp_func_call_paren"); - return(options::sp_func_call_paren()); - } - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - // spaces between function and open paren - if ( chunk_is_token(first, CT_FUNC_CALL) - || chunk_is_token(first, CT_FUNC_CTOR_VAR) - || chunk_is_token(first, CT_CNG_HASINC) - || chunk_is_token(first, CT_CNG_HASINCN) - || ( chunk_is_token(first, CT_BRACE_CLOSE) - && first->parent_type == CT_BRACED_INIT_LIST - && chunk_is_token(second, CT_FPAREN_OPEN))) - { - if ( (options::sp_func_call_paren_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Add or remove space between function name and '()' on function calls without - // parameters. If set to 'ignore' (the default), sp_func_call_paren is used. - log_rule("sp_func_call_paren_empty"); - return(options::sp_func_call_paren_empty()); - } - } - // Add or remove space between function name and '(' on function calls. - log_rule("sp_func_call_paren"); - return(options::sp_func_call_paren()); - } - - if (chunk_is_token(first, CT_FUNC_CALL_USER)) - { - // Add or remove space between the user function name and '(' on function - // calls. You need to set a keyword to be a user function in the config file, - // like: - // set func_call_user tr _ i18n - log_rule("sp_func_call_user_paren"); - return(options::sp_func_call_user_paren()); - } - - if ( chunk_is_token(first, CT_ATTRIBUTE) - && chunk_is_paren_open(second)) - { - // Add or remove space between '__attribute__' and '('. - log_rule("sp_attribute_paren"); - return(options::sp_attribute_paren()); - } - - if (chunk_is_token(first, CT_FUNC_DEF)) - { - if ( (options::sp_func_def_paren_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Add or remove space between function name and '()' on function definition - // without parameters. - log_rule("sp_func_def_paren_empty"); - return(options::sp_func_def_paren_empty()); - } - } - // Add or remove space between function name and '(' on function definition. - log_rule("sp_func_def_paren"); - return(options::sp_func_def_paren()); - } - - if ( chunk_is_token(first, CT_CPP_CAST) - || chunk_is_token(first, CT_TYPE_WRAP)) - { - // Add or remove space between the type and open parenthesis in a C++ cast, - // i.e. 'int(exp)' vs. 'int (exp)'. - log_rule("sp_cpp_cast_paren"); - return(options::sp_cpp_cast_paren()); - } - - if ( chunk_is_token(first, CT_SPAREN_CLOSE) - && chunk_is_token(second, CT_WHEN)) - { - // TODO: provide some test data to check this block - log_rule_short("FORCE"); - return(IARF_FORCE); // TODO: make this configurable? - } - - if ( chunk_is_token(first, CT_PAREN_CLOSE) - && ( chunk_is_token(second, CT_PAREN_OPEN) - || chunk_is_token(second, CT_FPAREN_OPEN))) - { - // "(int)a" vs. "(int) a" or "cast(int)a" vs. "cast(int) a" - if ( get_chunk_parent_type(first) == CT_C_CAST - || get_chunk_parent_type(first) == CT_D_CAST) - { - // Add or remove space after C/D cast, i.e. 'cast(int)a' vs. 'cast(int) a' or - // '(int)a' vs. '(int) a'. - log_rule("sp_after_cast"); - return(options::sp_after_cast()); - } - // Must be an indirect/chained function call? - log_rule_short("REMOVE"); - return(IARF_REMOVE); // TODO: make this configurable? - } - - // handle the space between parens in fcn type 'void (*f)(void)' - if (chunk_is_token(first, CT_TPAREN_CLOSE)) - { - // Add or remove space between the ')' and '(' in a function type, as in - // 'void (*x)(...)'. - log_rule("sp_after_tparen_close"); - return(options::sp_after_tparen_close()); - } - - // ")(" vs. ") (" - if ( ( chunk_is_str(first, ")", 1) - && chunk_is_str(second, "(", 1)) - || ( chunk_is_paren_close(first) - && chunk_is_paren_open(second))) - { - // Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. - log_rule("sp_cparen_oparen"); - return(options::sp_cparen_oparen()); - } - - if ( chunk_is_token(first, CT_FUNC_PROTO) - || ( chunk_is_token(second, CT_FPAREN_OPEN) - && get_chunk_parent_type(second) == CT_FUNC_PROTO)) - { - if ( (options::sp_func_proto_paren_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Add or remove space between function name and '()' on function declaration - // without parameters. - log_rule("sp_func_proto_paren_empty"); - return(options::sp_func_proto_paren_empty()); - } - } - // Add or remove space between function name and '(' on function declaration. - log_rule("sp_func_proto_paren"); - return(options::sp_func_proto_paren()); - } - - // Issue #2437 - if ( chunk_is_token(first, CT_FUNC_TYPE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - // Add or remove space between function name and '(' with a typedef specifier. - log_rule("sp_func_type_paren"); - return(options::sp_func_type_paren()); - } - - if ( chunk_is_token(first, CT_FUNC_CLASS_DEF) - || chunk_is_token(first, CT_FUNC_CLASS_PROTO)) - { - if ( (options::sp_func_class_paren_empty() != IARF_IGNORE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - chunk_t *next = chunk_get_next_ncnnl(second); - - if (chunk_is_token(next, CT_FPAREN_CLOSE)) - { - // Add or remove space between a constructor without parameters or destructor - // and '()'. - log_rule("sp_func_class_paren_empty"); - return(options::sp_func_class_paren_empty()); - } - } - // Add or remove space between a constructor/destructor and the open - // parenthesis. - log_rule("sp_func_class_paren"); - return(options::sp_func_class_paren()); - } - - if ( chunk_is_token(first, CT_CLASS) - && !first->flags.test(PCF_IN_OC_MSG)) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if ( chunk_is_token(first, CT_BRACE_OPEN) - && chunk_is_token(second, CT_BRACE_CLOSE)) - { - // Add or remove space inside '{}'. - log_rule("sp_inside_braces_empty"); - return(options::sp_inside_braces_empty()); - } - - if ( ( chunk_is_token(first, CT_TYPE) // Issue #2428 - || chunk_is_token(first, CT_ANGLE_CLOSE)) - && chunk_is_token(second, CT_BRACE_OPEN) - && get_chunk_parent_type(second) == CT_BRACED_INIT_LIST) - { - iarf_flags_t arg = iarf_flags_t{ options::sp_type_brace_init_lst() }; - - if ( arg != IARF_IGNORE - || get_chunk_parent_type(first) != CT_DECLTYPE) - { - // 'int{9}' vs. 'int {9}' - // Add or remove space between type and open brace of an unnamed temporary - // direct-list-initialization. - log_rule("sp_type_brace_init_lst"); - return(arg); - } - } - - if ( ( chunk_is_token(first, CT_WORD) // Issue #2428 - || chunk_is_token(first, CT_SQUARE_CLOSE) - || chunk_is_token(first, CT_TSQUARE)) - && chunk_is_token(second, CT_BRACE_OPEN) - && get_chunk_parent_type(second) == CT_BRACED_INIT_LIST) - { - // Add or remove space between a variable and '{' for C++ uniform - // initialization. - auto arg = iarf_flags_t{ options::sp_word_brace_init_lst() }; - - if ( arg != IARF_IGNORE - || get_chunk_parent_type(first) != CT_DECLTYPE) - { - // 'a{9}' vs. 'a {9}' - // Add or remove space between variable/word and open brace of an unnamed - // temporary direct-list-initialization. - log_rule("sp_word_brace_init_lst"); - return(arg); - } - } - - if (chunk_is_token(second, CT_BRACE_CLOSE)) - { - if (get_chunk_parent_type(second) == CT_ENUM) - { - // Add or remove space inside enum '{' and '}'. - log_rule("sp_inside_braces_enum"); - return(options::sp_inside_braces_enum()); - } - - if ( get_chunk_parent_type(second) == CT_STRUCT - || get_chunk_parent_type(second) == CT_UNION) - { - // Fix for issue #1240 adding space in struct initializers - chunk_t *tmp = chunk_get_prev_ncnnl(chunk_skip_to_match_rev(second)); - - if (chunk_is_token(tmp, CT_ASSIGN)) - { - // TODO: provide some test data to check this block - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - // Add or remove space inside struct/union '{' and '}'. - log_rule("sp_inside_braces_struct"); - return(options::sp_inside_braces_struct()); - } - else if ( get_chunk_parent_type(second) == CT_OC_AT - && options::sp_inside_braces_oc_dict() != IARF_IGNORE) - { - // (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' - log_rule("sp_inside_braces_oc_dict"); - return(options::sp_inside_braces_oc_dict()); - } - - if (get_chunk_parent_type(second) == CT_BRACED_INIT_LIST) - { - // Add or remove space between nested braces, i.e. '{{' vs. '{ {'. - // only to help the vim command }}}} - if ( options::sp_brace_brace() != IARF_IGNORE - && chunk_is_token(first, CT_BRACE_CLOSE) - && get_chunk_parent_type(first) == CT_BRACED_INIT_LIST) - { - log_rule("sp_brace_brace"); - return(options::sp_brace_brace()); - } - - if (options::sp_before_type_brace_init_lst_close() != IARF_IGNORE) - { - // Add or remove space before close brace in an unnamed temporary - // direct-list-initialization. - log_rule("sp_before_type_brace_init_lst_close"); - return(options::sp_before_type_brace_init_lst_close()); - } - - if (options::sp_inside_type_brace_init_lst() != IARF_IGNORE) - { - // Add or remove space inside an unnamed temporary direct-list-initialization. - log_rule("sp_inside_type_brace_init_lst"); - return(options::sp_inside_type_brace_init_lst()); - } - } - // Add or remove space inside '{' and '}'. - log_rule("sp_inside_braces"); - return(options::sp_inside_braces()); - } - - if (chunk_is_token(first, CT_D_CAST)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_PP_DEFINED) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'defined' and '(' in '#if defined (FOO)'. - log_rule("sp_defined_paren"); - return(options::sp_defined_paren()); - } - - if (chunk_is_token(first, CT_THROW)) - { - if (chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'throw' and '(' in 'throw (something)'. - log_rule("sp_throw_paren"); - return(options::sp_throw_paren()); - } - // Add or remove space between 'throw' and anything other than '(' as in - // '@throw [...];'. - log_rule("sp_after_throw"); - return(options::sp_after_throw()); - } - - if ( chunk_is_token(first, CT_THIS) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'this' and '(' in 'this (something)'. - log_rule("sp_this_paren"); - return(options::sp_this_paren()); - } - - if ( chunk_is_token(first, CT_STATE) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - log_rule_short("ADD"); - return(IARF_ADD); - } - - if ( chunk_is_token(first, CT_DELEGATE) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_MEMBER) - || chunk_is_token(second, CT_MEMBER)) - { - // Add or remove space around the '.' or '->' operators. - log_rule("sp_member"); - return(options::sp_member()); - } - - if (chunk_is_token(first, CT_C99_MEMBER)) - { - // always remove space(s) after then '.' of a C99-member - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_SUPER) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'super' and '(' in 'super (something)'. - log_rule("sp_super_paren"); - return(options::sp_super_paren()); - } - - if ( chunk_is_token(first, CT_FPAREN_CLOSE) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - if (get_chunk_parent_type(second) == CT_DOUBLE_BRACE) - { - // (Java) Add or remove space between ')' and '{{' of double brace initializer. - // only to help the vim command }} - log_rule("sp_fparen_dbrace"); - return(options::sp_fparen_dbrace()); - } - - // To fix issue #1234 - // check for initializers and add space or ignore based on the option. - if (get_chunk_parent_type(first) == CT_FUNC_CALL) - { - chunk_t *tmp = chunk_get_prev_type(first, get_chunk_parent_type(first), first->level); - tmp = chunk_get_prev_ncnnl(tmp); - - if (chunk_is_token(tmp, CT_NEW)) - { - // Add or remove space between ')' and '{' of s function call in object - // initialization. - // Overrides sp_fparen_brace. - log_rule("sp_fparen_brace_initializer"); - return(options::sp_fparen_brace_initializer()); - } - } - // Add or remove space between ')' and '{' of function. - log_rule("sp_fparen_brace"); - return(options::sp_fparen_brace()); - } - - if ( chunk_is_token(first, CT_D_TEMPLATE) - || chunk_is_token(second, CT_D_TEMPLATE)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_ELSE) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between 'else' and '{' if on the same line. - log_rule("sp_else_brace"); - return(options::sp_else_brace()); - } - - if ( chunk_is_token(first, CT_ELSE) - && chunk_is_token(second, CT_ELSEIF)) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if ( chunk_is_token(first, CT_FINALLY) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between 'finally' and '{' if on the same line. - log_rule("sp_finally_brace"); - return(options::sp_finally_brace()); - } - - if ( chunk_is_token(first, CT_TRY) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between 'try' and '{' if on the same line. - log_rule("sp_try_brace"); - return(options::sp_try_brace()); - } - - if ( chunk_is_token(first, CT_GETSET) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between get/set and '{' if on the same line. - log_rule("sp_getset_brace"); - return(options::sp_getset_brace()); - } - - if ( chunk_is_token(first, CT_WORD) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - if (get_chunk_parent_type(first) == CT_NAMESPACE) - { - // Add or remove space between a variable and '{' for a namespace. - log_rule("sp_word_brace_ns"); - return(options::sp_word_brace_ns()); - } - } - - if ( chunk_is_token(second, CT_PAREN_OPEN) - && get_chunk_parent_type(second) == CT_INVARIANT) - { - // (D) Add or remove space between 'invariant' and '('. - log_rule("sp_invariant_paren"); - return(options::sp_invariant_paren()); - } - - if ( chunk_is_token(first, CT_PAREN_CLOSE) - && get_chunk_parent_type(first) != CT_DECLTYPE) - { - if (get_chunk_parent_type(first) == CT_INVARIANT) - { - // (D) Add or remove space after the ')' in 'invariant (C) c'. - log_rule("sp_after_invariant_paren"); - return(options::sp_after_invariant_paren()); - } - - // "(struct foo) {...}" vs. "(struct foo){...}" - if (chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between ')' and '{'. - log_rule("sp_paren_brace"); - return(options::sp_paren_brace()); - } - - // D-specific: "delegate(some thing) dg - if (get_chunk_parent_type(first) == CT_DELEGATE) - { - log_rule_short("ADD"); - return(IARF_ADD); - } - - // PAWN-specific: "state (condition) next" - if (get_chunk_parent_type(first) == CT_STATE) - { - log_rule_short("ADD"); - return(IARF_ADD); - } - - /* C++ new operator: new(bar) Foo */ - if (get_chunk_parent_type(first) == CT_NEW) - { - // Add or remove space between ')' and type in 'new(foo) BAR'. - log_rule("sp_after_newop_paren"); - return(options::sp_after_newop_paren()); - } - } - - /* "((" vs. "( (" or "))" vs. ") )" */ - // Issue #1342 - if ( ( chunk_is_str(first, "(", 1) - && chunk_is_str(second, "(", 1)) - || ( chunk_is_str(first, ")", 1) - && chunk_is_str(second, ")", 1))) - { - if (get_chunk_parent_type(second) == CT_FUNC_CALL_USER) - { - // Add or remove space between nested parentheses with user functions, - // i.e. '((' vs. '( ('. - log_rule("sp_func_call_user_paren_paren"); - return(options::sp_func_call_user_paren_paren()); - } - // Add or remove space between nested parentheses, i.e. '((' vs. ') )'. - log_rule("sp_paren_paren"); - return(options::sp_paren_paren()); - } - - // "foo(...)" vs. "foo( ... )" - if ( chunk_is_token(first, CT_FPAREN_OPEN) - || chunk_is_token(second, CT_FPAREN_CLOSE)) - { - if ( (get_chunk_parent_type(first) == CT_FUNC_CALL_USER) - || ( (get_chunk_parent_type(second) == CT_FUNC_CALL_USER) - && ( (chunk_is_token(first, CT_WORD)) - || (chunk_is_token(first, CT_SQUARE_CLOSE))))) - { - // Add or remove space inside user function '(' and ')'. - log_rule("sp_func_call_user_inside_fparen"); - return(options::sp_func_call_user_inside_fparen()); - } - - if ( chunk_is_token(first, CT_FPAREN_OPEN) - && chunk_is_token(second, CT_FPAREN_CLOSE)) - { - // Add or remove space inside empty function '()'. - log_rule("sp_inside_fparens"); - return(options::sp_inside_fparens()); - } - // Add or remove space inside function '(' and ')'. - log_rule("sp_inside_fparen"); - return(options::sp_inside_fparen()); - } - - // "foo(...)" vs. "foo( ... )" - if ( chunk_is_token(first, CT_TPAREN_OPEN) - || chunk_is_token(second, CT_TPAREN_CLOSE)) - { - // Add or remove space inside the first parentheses in a function type, as in - // 'void (*x)(...)'. - log_rule("sp_inside_tparen"); - return(options::sp_inside_tparen()); - } - - if (chunk_is_token(first, CT_PAREN_CLOSE)) - { - if ( first->flags.test(PCF_OC_RTYPE) // == CT_OC_RTYPE) - && ( get_chunk_parent_type(first) == CT_OC_MSG_DECL - || get_chunk_parent_type(first) == CT_OC_MSG_SPEC)) - { - // (OC) Add or remove space after the first (type) in message specs, - // i.e. '-(int) f:(int)x;' vs. '-(int)f:(int)x;'. - log_rule("sp_after_oc_return_type"); - return(options::sp_after_oc_return_type()); - } - - if ( get_chunk_parent_type(first) == CT_OC_MSG_SPEC - || get_chunk_parent_type(first) == CT_OC_MSG_DECL) - { - // (OC) Add or remove space after the (type) in message specs, - // i.e. '-(int)f: (int) x;' vs. '-(int)f: (int)x;'. - log_rule("sp_after_oc_type"); - return(options::sp_after_oc_type()); - } - - if ( get_chunk_parent_type(first) == CT_OC_SEL - && second->type != CT_SQUARE_CLOSE) - { - // (OC) Add or remove space between '@selector(x)' and the following word, - // i.e. '@selector(foo) a:' vs. '@selector(foo)a:'. - log_rule("sp_after_oc_at_sel_parens"); - return(options::sp_after_oc_at_sel_parens()); - } - } - - if (options::sp_inside_oc_at_sel_parens() != IARF_IGNORE) - { - if ( ( chunk_is_token(first, CT_PAREN_OPEN) - && ( get_chunk_parent_type(first) == CT_OC_SEL - || get_chunk_parent_type(first) == CT_OC_PROTOCOL)) - || ( chunk_is_token(second, CT_PAREN_CLOSE) - && ( get_chunk_parent_type(second) == CT_OC_SEL - || get_chunk_parent_type(second) == CT_OC_PROTOCOL))) - { - // (OC) Add or remove space inside '@selector' parentheses, - // i.e. '@selector(foo)' vs. '@selector( foo )'. - // Also applies to '@protocol()' constructs. - log_rule("sp_inside_oc_at_sel_parens"); - return(options::sp_inside_oc_at_sel_parens()); - } - } - - if ( chunk_is_token(second, CT_PAREN_OPEN) - && ( chunk_is_token(first, CT_OC_SEL) - || chunk_is_token(first, CT_OC_PROTOCOL))) - { - // (OC) Add or remove space between '@selector' and '(', - // i.e. '@selector(msgName)' vs. '@selector (msgName)'. - // Also applies to '@protocol()' constructs. - log_rule("sp_after_oc_at_sel"); - return(options::sp_after_oc_at_sel()); - } - - /* - * C cast: "(int)" vs. "( int )" - * D cast: "cast(int)" vs. "cast( int )" - * CPP cast: "int(a + 3)" vs. "int( a + 3 )" - */ - if (chunk_is_token(first, CT_PAREN_OPEN)) - { - if ( get_chunk_parent_type(first) == CT_C_CAST - || get_chunk_parent_type(first) == CT_CPP_CAST - || get_chunk_parent_type(first) == CT_D_CAST) - { - // Add or remove spaces inside cast parentheses. - log_rule("sp_inside_paren_cast"); - return(options::sp_inside_paren_cast()); - } - - if (get_chunk_parent_type(first) == CT_NEW) - { - if (options::sp_inside_newop_paren_open() != IARF_IGNORE) - { - // Add or remove space after the open parenthesis of the new operator, - // as in 'new(foo) BAR'. - // Overrides sp_inside_newop_paren. - log_rule("sp_inside_newop_paren_open"); - return(options::sp_inside_newop_paren_open()); - } - - if (options::sp_inside_newop_paren() != IARF_IGNORE) - { - // Add or remove space inside parenthesis of the new operator - // as in 'new(foo) BAR'. - log_rule("sp_inside_newop_paren"); - return(options::sp_inside_newop_paren()); - } - } - log_rule("sp_inside_paren"); - return(options::sp_inside_paren()); - } - - if (chunk_is_token(second, CT_PAREN_CLOSE)) - { - if ( get_chunk_parent_type(second) == CT_C_CAST - || get_chunk_parent_type(second) == CT_CPP_CAST - || get_chunk_parent_type(second) == CT_D_CAST) - { - // Add or remove spaces inside cast parentheses. - log_rule("sp_inside_paren_cast"); - return(options::sp_inside_paren_cast()); - } - - if (get_chunk_parent_type(second) == CT_NEW) - { - if (options::sp_inside_newop_paren_close() != IARF_IGNORE) - { - // Add or remove space before the close parenthesis of the new operator, - // as in 'new(foo) BAR'. - // Overrides sp_inside_newop_paren. - log_rule("sp_inside_newop_paren_close"); - return(options::sp_inside_newop_paren_close()); - } - - if (options::sp_inside_newop_paren() != IARF_IGNORE) - { - // Add or remove space inside parenthesis of the new operator - // as in 'new(foo) BAR'. - log_rule("sp_inside_newop_paren"); - return(options::sp_inside_newop_paren()); - } - } - // Add or remove space inside '(' and ')'. - log_rule("sp_inside_paren"); - return(options::sp_inside_paren()); - } - - if ( chunk_is_token(first, CT_SQUARE_OPEN) - && chunk_is_token(second, CT_SQUARE_CLOSE)) - { - // Add or remove space inside '[]'. - log_rule("sp_inside_square_empty"); - return(options::sp_inside_square_empty()); - } - - // "[3]" vs. "[ 3 ]" or for objective-c "@[@3]" vs. "@[ @3 ]" - if ( chunk_is_token(first, CT_SQUARE_OPEN) - || chunk_is_token(second, CT_SQUARE_CLOSE)) - { - if ( language_is_set(LANG_OC) - && ( ( get_chunk_parent_type(first) == CT_OC_AT - && chunk_is_token(first, CT_SQUARE_OPEN)) - || ( get_chunk_parent_type(second) == CT_OC_AT - && chunk_is_token(second, CT_SQUARE_CLOSE))) - && (options::sp_inside_square_oc_array() != IARF_IGNORE)) - { - // (OC) Add or remove space inside a non-empty Objective-C boxed array '@[' and - // ']'. If set to ignore, sp_inside_square is used. - log_rule("sp_inside_square_oc_array"); - return(options::sp_inside_square_oc_array()); - } - // Add or remove space inside a non-empty '[' and ']'. - log_rule("sp_inside_square"); - return(options::sp_inside_square()); - } - - if ( chunk_is_token(first, CT_SQUARE_CLOSE) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - // Add or remove space between ']' and '(' when part of a function call. - log_rule("sp_square_fparen"); - return(options::sp_square_fparen()); - } - - // "if(...)" vs. "if( ... )" - if ( chunk_is_token(second, CT_SPAREN_CLOSE) - && (options::sp_inside_sparen_close() != IARF_IGNORE)) - { - // Add or remove space before ')' of control statements. - // Overrides sp_inside_sparen. - log_rule("sp_inside_sparen_close"); - return(options::sp_inside_sparen_close()); - } - - if ( chunk_is_token(first, CT_SPAREN_OPEN) - && (options::sp_inside_sparen_open() != IARF_IGNORE)) - { - // Add or remove space after '(' of control statements. - // Overrides sp_inside_sparen. - log_rule("sp_inside_sparen_open"); - return(options::sp_inside_sparen_open()); - } - - if ( chunk_is_token(first, CT_SPAREN_OPEN) - || chunk_is_token(second, CT_SPAREN_CLOSE)) - { - // Add or remove space inside '(' and ')' of control statements. - log_rule("sp_inside_sparen"); - return(options::sp_inside_sparen()); - } - - if (chunk_is_token(first, CT_CLASS_COLON)) - { - //chunk_t *a = chunk_get_prev_type(first, CT_OC_INTF, first->level, scope_e::ALL); - //chunk_t *b = chunk_get_prev_type(first, CT_OC_IMPL, first->level, scope_e::ALL); - //bool B_a = a != nullptr; - //bool B_b = b != nullptr; - if ( get_chunk_parent_type(first) == CT_OC_CLASS - && ( !chunk_get_prev_type(first, CT_OC_INTF, first->level, scope_e::ALL) - && !chunk_get_prev_type(first, CT_OC_IMPL, first->level, scope_e::ALL))) - { - if (options::sp_after_oc_colon() != IARF_IGNORE) - { - // TODO: provide some test data to check this block - // (OC) Add or remove space after the colon in message specs, - // i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. - log_rule("sp_after_oc_colon"); - return(options::sp_after_oc_colon()); - } - } - - if (options::sp_after_class_colon() != IARF_IGNORE) - { - // Add or remove space after class ':'. - log_rule("sp_after_class_colon"); - return(options::sp_after_class_colon()); - } - } - - if (chunk_is_token(second, CT_CLASS_COLON)) - { - if ( get_chunk_parent_type(second) == CT_OC_CLASS - && ( !chunk_get_prev_type(second, CT_OC_INTF, second->level, scope_e::ALL) - && !chunk_get_prev_type(second, CT_OC_IMPL, second->level, scope_e::ALL))) - { - if ( get_chunk_parent_type(second) == CT_OC_CLASS - && !chunk_get_prev_type(second, CT_OC_INTF, second->level, scope_e::ALL)) - { - if (options::sp_before_oc_colon() != IARF_IGNORE) - { - // TODO: provide some test data to check this block - // (OC) Add or remove space before the colon in message specs, - // i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. - log_rule("sp_before_oc_colon"); - return(options::sp_before_oc_colon()); - } - } - } - - if (options::sp_before_class_colon() != IARF_IGNORE) - { - // Add or remove space before class ':'. - log_rule("sp_before_class_colon"); - return(options::sp_before_class_colon()); - } - } - - if ( (options::sp_after_constr_colon() != IARF_IGNORE) - && chunk_is_token(first, CT_CONSTR_COLON)) - { - min_sp = options::indent_ctor_init_leading() - 1; // default indent is 1 space - - // Add or remove space after class constructor ':'. - log_rule("sp_after_constr_colon"); - return(options::sp_after_constr_colon()); - } - - if ( (options::sp_before_constr_colon() != IARF_IGNORE) - && chunk_is_token(second, CT_CONSTR_COLON)) - { - // Add or remove space before class constructor ':'. - log_rule("sp_before_constr_colon"); - return(options::sp_before_constr_colon()); - } - - if ( (options::sp_before_case_colon() != IARF_IGNORE) - && chunk_is_token(second, CT_CASE_COLON)) - { - // Add or remove space before case ':'. - log_rule("sp_before_case_colon"); - return(options::sp_before_case_colon()); - } - - if (chunk_is_token(first, CT_DOT)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(second, CT_DOT)) - { - log_rule_short("ADD"); - return(IARF_ADD); - } - - if ( chunk_is_token(first, CT_NULLCOND) - || chunk_is_token(second, CT_NULLCOND)) - { - // TODO: provide some test data to check this block - // LANG_CS null conditional operator - // Add or remove space around the '.' or '->' operators. - log_rule("sp_member"); - return(options::sp_member()); - } - - if ( chunk_is_token(first, CT_ARITH) - || chunk_is_token(first, CT_SHIFT) - || chunk_is_token(first, CT_CARET) - || chunk_is_token(second, CT_ARITH) - || chunk_is_token(second, CT_SHIFT) - || chunk_is_token(second, CT_CARET)) - { - // Add or remove space around arithmetic operators '+' and '-'. - // Overrides sp_arith. - if (options::sp_arith_additive() != IARF_IGNORE) - { - auto arith_char = ( chunk_is_token(first, CT_ARITH) - || chunk_is_token(first, CT_SHIFT) - || chunk_is_token(first, CT_CARET)) - ? first->str[0] : second->str[0]; - - if ( arith_char == '+' - || arith_char == '-') - { - log_rule("sp_arith_additive"); - return(options::sp_arith_additive()); - } - } - // Add or remove space around non-assignment symbolic operators ('+', '/', '%', - // '<<', and so forth). - log_rule("sp_arith"); - return(options::sp_arith()); - } - - if ( chunk_is_token(first, CT_BOOL) - || chunk_is_token(second, CT_BOOL)) - { - // Add or remove space around boolean operators '&&' and '||'. - iarf_e arg = options::sp_bool(); - - if ( (options::pos_bool() != TP_IGNORE) - && first->orig_line != second->orig_line - && arg != IARF_REMOVE) - { - arg = arg | IARF_ADD; - } - // TODO check it - log_rule("sp_bool"); - return(arg); - } - - if ( chunk_is_token(first, CT_COMPARE) - || chunk_is_token(second, CT_COMPARE)) - { - // Add or remove space around compare operator '<', '>', '==', etc. - log_rule("sp_compare"); - return(options::sp_compare()); - } - - if ( chunk_is_token(first, CT_PAREN_OPEN) - && chunk_is_token(second, CT_PTR_TYPE)) - { - // TODO: provide some test data to check this block - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if ( chunk_is_token(first, CT_PTR_TYPE) - && (options::sp_ptr_star_paren() != IARF_IGNORE) - && ( chunk_is_token(second, CT_FPAREN_OPEN) - || chunk_is_token(second, CT_TPAREN_OPEN))) - { - // Add or remove space after a pointer star '*', if followed by an open - // parenthesis, as in 'void* (*)(). - log_rule("sp_ptr_star_paren"); - return(options::sp_ptr_star_paren()); - } - - if ( chunk_is_token(first, CT_PTR_TYPE) - && chunk_is_token(second, CT_PTR_TYPE) - && (options::sp_between_ptr_star() != IARF_IGNORE)) - { - // Add or remove space between pointer stars '*'. - log_rule("sp_between_ptr_star"); - return(options::sp_between_ptr_star()); - } - - if ( chunk_is_token(first, CT_PTR_TYPE) - && (options::sp_after_ptr_star_func() != IARF_IGNORE) - && ( get_chunk_parent_type(first) == CT_FUNC_DEF - || get_chunk_parent_type(first) == CT_FUNC_PROTO - || get_chunk_parent_type(first) == CT_FUNC_VAR)) - { - // Add or remove space after a pointer star '*', if followed by a function - // prototype or function definition. - log_rule("sp_after_ptr_star_func"); - return(options::sp_after_ptr_star_func()); - } - - if ( chunk_is_token(first, CT_PTR_TYPE) - && CharTable::IsKw1(second->str[0])) - { - chunk_t *prev = chunk_get_prev(first); - - if (chunk_is_token(prev, CT_IN)) - { - // Add or remove space after the '*' (dereference) unary operator. This does - // not affect the spacing after a '*' that is part of a type. - log_rule("sp_deref"); - return(options::sp_deref()); - } - - if ( ( get_chunk_parent_type(first) == CT_FUNC_VAR - || get_chunk_parent_type(first) == CT_FUNC_TYPE) - && options::sp_after_ptr_block_caret() != IARF_IGNORE) - { - // Add or remove space after pointer caret '^', if followed by a word. - log_rule("sp_after_ptr_block_caret"); - return(options::sp_after_ptr_block_caret()); - } - - if ( chunk_is_token(second, CT_QUALIFIER) - && (options::sp_after_ptr_star_qualifier() != IARF_IGNORE)) - { - // Add or remove space after pointer star '*', if followed by a qualifier. - log_rule("sp_after_ptr_star_qualifier"); - return(options::sp_after_ptr_star_qualifier()); - } - - // Add or remove space after pointer star '*', if followed by a word. - if (options::sp_after_ptr_star() != IARF_IGNORE) - { - log_rule("sp_after_ptr_star"); - return(options::sp_after_ptr_star()); - } - } - - if ( chunk_is_token(first, CT_PTR_TYPE) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space after pointer star '*', if followed by a word. - log_rule("sp_after_ptr_star"); - return(options::sp_after_ptr_star()); - } - - if ( chunk_is_token(second, CT_PTR_TYPE) - && first->type != CT_IN) - { - if ( language_is_set(LANG_CS) - && chunk_is_nullable(second)) - { - min_sp = 0; - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - // Add or remove space before a pointer star '*', if followed by a function - // prototype or function definition. - if (options::sp_before_ptr_star_func() != IARF_IGNORE) - { - // Find the next non-'*' chunk - chunk_t *next = second; - - do - { - next = chunk_get_next(next); - } while (chunk_is_token(next, CT_PTR_TYPE)); - - if ( chunk_is_token(next, CT_FUNC_DEF) - || chunk_is_token(next, CT_FUNC_PROTO)) - { - log_rule("sp_before_ptr_star_func"); - return(options::sp_before_ptr_star_func()); - } - } - - // Add or remove space before pointer star '*' that isn't followed by a - // variable name. If set to 'ignore', sp_before_ptr_star is used instead. - if (options::sp_before_unnamed_ptr_star() != IARF_IGNORE) - { - chunk_t *next = chunk_get_next_nc(second); - - while (chunk_is_token(next, CT_PTR_TYPE)) - { - next = chunk_get_next_nc(next); - } - - if ( next != nullptr - && next->type != CT_WORD) - { - log_rule("sp_before_unnamed_ptr_star"); - return(options::sp_before_unnamed_ptr_star()); - } - } - - // Add or remove space before pointer star '*'. - if (options::sp_before_ptr_star() != IARF_IGNORE) - { - log_rule("sp_before_ptr_star"); - return(options::sp_before_ptr_star()); - } - } - - if (chunk_is_token(first, CT_OPERATOR)) - { - // Add or remove space between 'operator' and operator sign. - log_rule("sp_after_operator"); - return(options::sp_after_operator()); - } - - if ( chunk_is_token(second, CT_FUNC_PROTO) - || chunk_is_token(second, CT_FUNC_DEF)) - { - if ( first->type != CT_PTR_TYPE - && first->type != CT_BYREF) - { - // Add or remove space between return type and function name. A - // minimum of 1 is forced except for pointer/reference return types. - log_rule("sp_type_func | ADD"); - return(options::sp_type_func() | IARF_ADD); - } - // Add or remove space between return type and function name. A - // minimum of 1 is forced except for pointer/reference return types. - log_rule("sp_type_func"); - return(options::sp_type_func()); - } - - // "(int)a" vs. "(int) a" or "cast(int)a" vs. "cast(int) a" - if ( ( get_chunk_parent_type(first) == CT_C_CAST - || get_chunk_parent_type(first) == CT_D_CAST) - && chunk_is_token(first, CT_PAREN_CLOSE)) - { - log_rule("sp_after_cast"); - return(options::sp_after_cast()); - } - - if (chunk_is_token(first, CT_BRACE_CLOSE)) - { - if (chunk_is_token(second, CT_ELSE)) - { - // Add or remove space between '}' and 'else' if on the same line. - log_rule("sp_brace_else"); - return(options::sp_brace_else()); - } - - if ( language_is_set(LANG_OC) - && chunk_is_token(second, CT_CATCH) - && (options::sp_oc_brace_catch() != IARF_IGNORE)) - { - // TODO: provide some test data to check this block - // (OC) Add or remove space between '}' and '@catch' if on the same line. - // If set to ignore, sp_brace_catch is used. - log_rule("sp_oc_brace_catch"); - return(options::sp_oc_brace_catch()); - } - - if (chunk_is_token(second, CT_CATCH)) - { - // TODO: provide some test data to check this block - // Add or remove space between '}' and 'catch' if on the same line. - log_rule("sp_brace_catch"); - return(options::sp_brace_catch()); - } - - if (chunk_is_token(second, CT_FINALLY)) - { - // Add or remove space between '}' and 'finally' if on the same line. - log_rule("sp_brace_finally"); - return(options::sp_brace_finally()); - } - } - - if (chunk_is_token(first, CT_BRACE_OPEN)) - { - if (get_chunk_parent_type(first) == CT_ENUM) - { - // Add or remove space inside enum '{' and '}'. - log_rule("sp_inside_braces_enum"); - return(options::sp_inside_braces_enum()); - } - - if ( get_chunk_parent_type(first) == CT_STRUCT - || get_chunk_parent_type(first) == CT_UNION) - { - // Fix for issue #1240 adding space in struct initializers - chunk_t *tmp = chunk_get_prev_ncnnl(first); - - if (chunk_is_token(tmp, CT_ASSIGN)) - { - // TODO: provide some test data to check this block - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - // Add or remove space inside struct/union '{' and '}'. - log_rule("sp_inside_braces_struct"); - return(options::sp_inside_braces_struct()); - } - else if ( get_chunk_parent_type(first) == CT_OC_AT - && options::sp_inside_braces_oc_dict() != IARF_IGNORE) - { - // (OC) Add or remove space inside Objective-C boxed dictionary '{' and '}' - log_rule("sp_inside_braces_oc_dict"); - return(options::sp_inside_braces_oc_dict()); - } - - if (get_chunk_parent_type(first) == CT_BRACED_INIT_LIST) - { - // Add or remove space between nested braces, i.e. '{{' vs. '{ {'. - // only to help the vim command }}}} - if ( options::sp_brace_brace() != IARF_IGNORE - && chunk_is_token(second, CT_BRACE_OPEN) - && get_chunk_parent_type(second) == CT_BRACED_INIT_LIST) - { - log_rule("sp_brace_brace"); - return(options::sp_brace_brace()); - } - - if (options::sp_after_type_brace_init_lst_open() != IARF_IGNORE) - { - // Add or remove space after open brace in an unnamed temporary - // direct-list-initialization. - log_rule("sp_after_type_brace_init_lst_open"); - return(options::sp_after_type_brace_init_lst_open()); - } - - if (options::sp_inside_type_brace_init_lst() != IARF_IGNORE) - { - // Add or remove space inside an unnamed temporary direct-list-initialization. - log_rule("sp_inside_type_brace_init_lst"); - return(options::sp_inside_type_brace_init_lst()); - } - } - - if (!chunk_is_comment(second)) - { - // Add or remove space inside '{' and '}'. - log_rule("sp_inside_braces"); - return(options::sp_inside_braces()); - } - } - - if ( chunk_is_token(first, CT_BRACE_CLOSE) - && first->flags.test(PCF_IN_TYPEDEF) - && ( get_chunk_parent_type(first) == CT_ENUM - || get_chunk_parent_type(first) == CT_STRUCT - || get_chunk_parent_type(first) == CT_UNION)) - { - // Add or remove space between '}' and the name of a typedef on the same line. - log_rule("sp_brace_typedef"); - return(options::sp_brace_typedef()); - } - - if ( chunk_is_token(second, CT_PAREN_OPEN) - && get_chunk_parent_type(second) == CT_TEMPLATE) - { - // (D) Add or remove space before the parenthesis in the D constructs - // 'template Foo(' and 'class Foo('. - log_rule("sp_before_template_paren"); - return(options::sp_before_template_paren()); - } - - // Issue #3080 - if ( chunk_is_token(first, CT_PAREN_CLOSE) - && get_chunk_parent_type(first) == CT_DECLTYPE - && ( chunk_is_token(second, CT_WORD) - || chunk_is_token(second, CT_BRACE_OPEN) - || chunk_is_token(second, CT_FUNC_CALL))) - { - iarf_e arg = options::sp_after_decltype(); - // Add or remove space between 'decltype(...)' and word, brace or function call. - log_rule("sp_after_decltype"); - return(arg); - } - - // Issue #3080 - if ( !language_is_set(LANG_D) - && chunk_is_token(first, CT_PAREN_CLOSE) - && chunk_is_token(second, CT_WORD)) - { - // Add or remove space between type and word. - log_rule("sp_after_type"); - return(options::sp_after_type()); - } - - if ( language_is_set(LANG_VALA) - && chunk_is_token(second, CT_QUESTION)) - { - // TODO: provide some test data to check this block - // Issue #2090 - // (D) Add or remove space between a type and '?'. - log_rule("sp_type_question"); - return(options::sp_type_question()); - } - - // see if the D template expression is used as a type - if ( language_is_set(LANG_D) - && chunk_is_token(first, CT_PAREN_CLOSE) - && get_chunk_parent_type(first) == CT_D_TEMPLATE) - { - if (get_chunk_parent_type(second) == CT_USING_ALIAS) - { - log_rule("sp_after_type | ADD"); - return(options::sp_after_type() | IARF_ADD); - } - - if (chunk_is_token(second, CT_WORD)) - { - chunk_t *open_paren = chunk_skip_to_match_rev(first); - chunk_t *type = chunk_get_prev(chunk_get_prev(open_paren)); - - if (chunk_is_token(type, CT_TYPE)) - { - log_rule("sp_after_type"); - return(options::sp_after_type()); - } - } - } - - if ( !chunk_is_token(second, CT_PTR_TYPE) - && ( chunk_is_token(first, CT_QUALIFIER) - || chunk_is_token(first, CT_TYPE))) - { - // Add or remove space between type and word. In cases where total removal of - // whitespace would be a syntax error, a value of 'remove' is treated the same - // as 'force'. - // - // This also affects some other instances of space following a type that are - // not covered by other options; for example, between the return type and - // parenthesis of a function type template argument, between the type and - // parenthesis of an array parameter, or between 'decltype(...)' and the - // following word. - iarf_e arg = options::sp_after_type(); - log_rule("sp_after_type"); - return(arg); - } - - // If nothing claimed the PTR_TYPE, then return ignore - if ( chunk_is_token(first, CT_PTR_TYPE) - || chunk_is_token(second, CT_PTR_TYPE)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - if (chunk_is_token(first, CT_NOT)) - { - // Add or remove space after the '!' (not) unary operator. - log_rule("sp_not"); - return(options::sp_not()); - } - - if (chunk_is_token(first, CT_INV)) - { - // Add or remove space after the '~' (invert) unary operator. - log_rule("sp_inv"); - return(options::sp_inv()); - } - - if (chunk_is_token(first, CT_ADDR)) - { - // Add or remove space after the '&' (address-of) unary operator. This does not - // affect the spacing after a '&' that is part of a type. - log_rule("sp_addr"); - return(options::sp_addr()); - } - - if (chunk_is_token(first, CT_DEREF)) - { - // Add or remove space after the '*' (dereference) unary operator. This does - // not affect the spacing after a '*' that is part of a type. - log_rule("sp_deref"); - return(options::sp_deref()); - } - - if ( chunk_is_token(first, CT_POS) - || chunk_is_token(first, CT_NEG)) - { - // Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. - log_rule("sp_sign"); - return(options::sp_sign()); - } - - if ( chunk_is_token(first, CT_INCDEC_BEFORE) - || chunk_is_token(second, CT_INCDEC_AFTER)) - { - // Add or remove space between '++' and '--' the word to which it is being - // applied, as in '(--x)' or 'y++;'. - log_rule("sp_incdec"); - return(options::sp_incdec()); - } - - if (chunk_is_token(second, CT_CS_SQ_COLON)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - if (chunk_is_token(first, CT_CS_SQ_COLON)) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if (chunk_is_token(first, CT_OC_SCOPE)) - { - // (OC) Add or remove space after the scope '+' or '-', as in '-(void) foo;' - // or '+(int) bar;'. - log_rule("sp_after_oc_scope"); - return(options::sp_after_oc_scope()); - } - - if (chunk_is_token(first, CT_OC_DICT_COLON)) - { - // (OC) Add or remove space after the colon in immutable dictionary expression - // 'NSDictionary *test = @{@"foo" :@"bar"};'. - log_rule("sp_after_oc_dict_colon"); - return(options::sp_after_oc_dict_colon()); - } - - if (chunk_is_token(second, CT_OC_DICT_COLON)) - { - // (OC) Add or remove space before the colon in immutable dictionary expression - // 'NSDictionary *test = @{@"foo" :@"bar"};'. - log_rule("sp_before_oc_dict_colon"); - return(options::sp_before_oc_dict_colon()); - } - - if (chunk_is_token(first, CT_OC_COLON)) - { - if (first->flags.test(PCF_IN_OC_MSG)) - { - // (OC) Add or remove space after the colon in message specs, - // i.e. '[object setValue:1];' vs. '[object setValue: 1];'. - log_rule("sp_after_send_oc_colon"); - return(options::sp_after_send_oc_colon()); - } - // (OC) Add or remove space after the colon in message specs, - // i.e. '-(int) f:(int) x;' vs. '-(int) f: (int) x;'. - log_rule("sp_after_oc_colon"); - return(options::sp_after_oc_colon()); - } - - if (chunk_is_token(second, CT_OC_COLON)) - { - if ( first->flags.test(PCF_IN_OC_MSG) - && ( chunk_is_token(first, CT_OC_MSG_FUNC) - || chunk_is_token(first, CT_OC_MSG_NAME))) - { - // (OC) Add or remove space before the colon in message specs, - // i.e. '[object setValue:1];' vs. '[object setValue :1];'. - log_rule("sp_before_send_oc_colon"); - return(options::sp_before_send_oc_colon()); - } - // (OC) Add or remove space before the colon in message specs, - // i.e. '-(int) f: (int) x;' vs. '-(int) f : (int) x;'. - log_rule("sp_before_oc_colon"); - return(options::sp_before_oc_colon()); - } - - if ( chunk_is_token(second, CT_COMMENT) - && get_chunk_parent_type(second) == CT_COMMENT_EMBED) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if (chunk_is_token(first, CT_COMMENT)) - { - log_rule_short("FORCE"); - return(IARF_FORCE); - } - - if ( chunk_is_token(first, CT_NEW) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // c# new Constraint, c++ new operator - // Add or remove space between 'new' and '(' in 'new()'. - log_rule("sp_between_new_paren"); - return(options::sp_between_new_paren()); - } - - if ( chunk_is_token(first, CT_NEW) - || chunk_is_token(first, CT_DELETE) - || ( chunk_is_token(first, CT_TSQUARE) - && get_chunk_parent_type(first) == CT_DELETE)) - { - // Add or remove space after 'new', 'delete' and 'delete[]'. - log_rule("sp_after_new"); - return(options::sp_after_new()); - } - - if ( chunk_is_token(first, CT_ANNOTATION) - && chunk_is_paren_open(second)) - { - // (Java) Add or remove space between an annotation and the open parenthesis. - log_rule("sp_annotation_paren"); - return(options::sp_annotation_paren()); - } - - if (chunk_is_token(first, CT_OC_PROPERTY)) - { - // (OC) Add or remove space after '@property'. - log_rule("sp_after_oc_property"); - return(options::sp_after_oc_property()); - } - - if ( chunk_is_token(first, CT_EXTERN) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // (D) Add or remove space between 'extern' and '(' as in 'extern (C)'. - log_rule("sp_extern_paren"); - return(options::sp_extern_paren()); - } - - if ( chunk_is_token(second, CT_TYPE) - && ( ( chunk_is_token(first, CT_STRING) - && get_chunk_parent_type(first) == CT_EXTERN) - || ( chunk_is_token(first, CT_FPAREN_CLOSE) - && get_chunk_parent_type(first) == CT_ATTRIBUTE))) - { - log_rule_short("FORCE"); - return(IARF_FORCE); /* TODO: make this configurable? */ - } - - if (chunk_is_token(first, CT_NOEXCEPT)) - { - // Add or remove space after 'noexcept'. - log_rule("sp_after_noexcept"); - return(options::sp_after_noexcept()); - } - - // Issue #2138 - if (chunk_is_token(first, CT_FPAREN_CLOSE)) - { - if (chunk_is_token(second, CT_QUALIFIER)) - { - // Add or remove space between ')' and a qualifier such as 'const'. - log_rule("sp_paren_qualifier"); - return(options::sp_paren_qualifier()); - } - else if (chunk_is_token(second, CT_NOEXCEPT)) - { - // Add or remove space between ')' and 'noexcept'. - log_rule("sp_paren_noexcept"); - return(options::sp_paren_noexcept()); - } - } - - // Issue #2098 - if ( chunk_is_token(first, CT_PP_PRAGMA) - && chunk_is_token(second, CT_PREPROC_BODY)) - { - log_rule_short("REMOVE"); - return(IARF_REMOVE); - } - - // Issue #1733 - if ( chunk_is_token(first, CT_OPERATOR_VAL) - && chunk_is_token(second, CT_TYPE)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - // Issue #995 - if ( chunk_is_token(first, CT_DO) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - // Add or remove space between 'do' and '{'. - log_rule("sp_do_brace_open"); - return(options::sp_do_brace_open()); - } - - // Issue #995 - if ( chunk_is_token(first, CT_WHILE_OF_DO) - && chunk_is_token(second, CT_PAREN_OPEN)) - { - // Add or remove space between 'while' and '('. - if (options::sp_while_paren_open() != IARF_IGNORE) - { - log_rule("sp_while_paren_open"); - return(options::sp_while_paren_open()); - } - log_rule("sp_before_sparen"); - return(options::sp_before_sparen()); - } - - // Issue #995 - if ( chunk_is_token(first, CT_BRACE_CLOSE) - && chunk_is_token(second, CT_WHILE_OF_DO)) - { - // Add or remove space between '}' and 'while. - log_rule("sp_brace_close_while"); - return(options::sp_brace_close_while()); - } - - // TODO: have a look to Issue #2186, why NEWLINE? - // Issue #2524 - if ( chunk_is_token(first, CT_NEWLINE) - && chunk_is_token(second, CT_BRACE_OPEN)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - // ============================================================= - // categorie 1 - // this table lists out all combos where a space should NOT be present - // CT_UNKNOWN is a wildcard. - for (auto it : no_space_table) - { - if ( ( it.first == CT_UNKNOWN - || it.first == first->type) - && ( it.second == CT_UNKNOWN - || it.second == second->type)) - { - log_rule("REMOVE from no_space_table"); - return(IARF_REMOVE); - } - } - - // ============================================================= - // categorie 2 - // this table lists out all combos where a space MUST be present - for (auto it : add_space_table) - { - if ( it.first == first->type - && it.second == second->type) - { - // TODO: if necessary create a new option - log_rule("ADD from add_space_table"); - return(IARF_ADD); - } - } - - // Issue #2386 - if ( chunk_is_token(first, CT_FORM_FEED) - || chunk_is_token(second, CT_FORM_FEED)) - { - log_rule_short("IGNORE"); - return(IARF_IGNORE); - } - - // TODO: if necessary create a new option - if ( chunk_is_token(first, CT_MACRO_FUNC_CALL) - && chunk_is_token(second, CT_FPAREN_OPEN)) - { - log_rule("IGNORE"); - return(IARF_IGNORE); - } - // ============================================================= - // categorie 3 - // these lines are only useful for debugging uncrustify itself - LOG_FMT(LSPACE, "\n\n%s(%d): WARNING: unrecognize do_space:\n", - __func__, __LINE__); - LOG_FMT(LSPACE, " first->orig_line is %zu, first->orig_col is %zu, first->text() '%s', first->type is %s\n", - first->orig_line, first->orig_col, first->text(), get_token_name(first->type)); - LOG_FMT(LSPACE, " second->orig_line is %zu, second->orig_col is %zu, second->text() '%s', second->type is %s\n", - second->orig_line, second->orig_col, second->text(), get_token_name(second->type)); - LOG_FMT(LSPACE, " Please make a call at https://github.com/uncrustify/uncrustify/issues/new\n"); - LOG_FMT(LSPACE, " or merge the line:\n"); - LOG_FMT(LSPACE, " {%s, %s},\n", - get_token_name(first->type), get_token_name(second->type)); - LOG_FMT(LSPACE, " in the file <Path_to_uncrustify>/src/add_space_table.h\n"); - - log_rule_short("ADD as default value"); - return(IARF_ADD); -} // do_space - - -static iarf_e ensure_force_space(chunk_t *first, chunk_t *second, iarf_e av) -{ - if (first->flags.test(PCF_FORCE_SPACE)) - { - LOG_FMT(LSPACE, "%s(%d): <force between '%s' and '%s'>", - __func__, __LINE__, first->text(), second->text()); - return(av | IARF_ADD); - } - return(av); -} - - -static iarf_e do_space_ensured(chunk_t *first, chunk_t *second, int &min_sp) -{ - iarf_e aa = ensure_force_space(first, second, do_space(first, second, min_sp)); - - return(aa); -} - - -void space_text(void) -{ - LOG_FUNC_ENTRY(); - - chunk_t *pc = chunk_get_head(); - - if (pc == nullptr) - { - return; - } - chunk_t *next; - size_t prev_column; - size_t column = pc->column; - - while (pc != nullptr) - { - if (chunk_is_token(pc, CT_NEWLINE)) - { - LOG_FMT(LSPACE, "%s(%d): orig_line is %zu, orig_col is %zu, <Newline>, nl is %zu\n", - __func__, __LINE__, pc->orig_line, pc->orig_col, pc->nl_count); - } - else - { - char copy[1000]; - LOG_FMT(LSPACE, "%s(%d): orig_line is %zu, orig_col is %zu, '%s' type is %s\n", - __func__, __LINE__, pc->orig_line, pc->orig_col, pc->elided_text(copy), get_token_name(pc->type)); - } - - if ( (options::use_options_overriding_for_qt_macros()) - && ( (strcmp(pc->text(), "SIGNAL") == 0) - || (strcmp(pc->text(), "SLOT") == 0))) - { - LOG_FMT(LSPACE, "%s(%d): orig_col is %zu, type is %s SIGNAL/SLOT found\n", - __func__, __LINE__, pc->orig_line, get_token_name(pc->type)); - chunk_flags_set(pc, PCF_IN_QT_MACRO); // flag the chunk for a second processing - - // save the values - save_set_options_for_QT(pc->level); - } - - // Bug # 637 - // If true, vbrace tokens are dropped to the previous token and skipped. - if (options::sp_skip_vbrace_tokens()) - { - next = chunk_get_next(pc); - - while ( chunk_is_blank(next) - && !chunk_is_newline(next) - && ( chunk_is_token(next, CT_VBRACE_OPEN) - || chunk_is_token(next, CT_VBRACE_CLOSE))) - { - LOG_FMT(LSPACE, "%s(%d): orig_line is %zu, orig_col is %zu, Skip %s (%zu+%zu)\n", - __func__, __LINE__, next->orig_line, next->orig_col, get_token_name(next->type), - pc->column, pc->str.size()); - next->column = pc->column + pc->str.size(); - next = chunk_get_next(next); - } - } - else - { - next = pc->next; - } - - if (!next) - { - break; - } - - // Issue # 481 - // Whether to balance spaces inside nested parentheses. - if ( QT_SIGNAL_SLOT_found - && options::sp_balance_nested_parens()) - { - chunk_t *nn = next->next; // Issue #2734 - - if ( nn != nullptr - && chunk_is_token(nn, CT_SPACE)) - { - chunk_del(nn); // remove the space - } - } - - /* - * If the current chunk contains a newline, do not change the column - * of the next item - */ - if ( chunk_is_token(pc, CT_NEWLINE) - || chunk_is_token(pc, CT_NL_CONT) - || chunk_is_token(pc, CT_COMMENT_MULTI)) - { - column = next->column; - } - else - { - // Set to the minimum allowed column - if (pc->nl_count == 0) - { - column += pc->len(); - } - else - { - column = pc->orig_col_end; - } - prev_column = column; - - /* - * Apply a general safety check - * If the two chunks combined will tokenize differently, then we - * must force a space. - * Two chunks -- "()" and "[]" will always tokenize differently. - * They are always safe to not have a space after them. - */ - chunk_flags_clr(pc, PCF_FORCE_SPACE); - - if ( (pc->len() > 0) - && !chunk_is_str(pc, "[]", 2) - && !chunk_is_str(pc, "{{", 2) - && !chunk_is_str(pc, "}}", 2) - && !chunk_is_str(pc, "()", 2) - && !pc->str.startswith("@\"")) - { - // Find the next non-empty chunk on this line - chunk_t *tmp = next; - - // TODO: better use chunk_search here - while ( tmp != nullptr - && (tmp->len() == 0) - && !chunk_is_newline(tmp)) - { - tmp = chunk_get_next(tmp); - } - - if ( tmp != nullptr - && tmp->len() > 0) - { - bool kw1 = CharTable::IsKw2(pc->str[pc->len() - 1]); - bool kw2 = CharTable::IsKw1(next->str[0]); - - if ( kw1 - && kw2) - { - // back-to-back words need a space - LOG_FMT(LSPACE, "%s(%d): back-to-back words need a space: pc->text() '%s', next->text() '%s'\n", - __func__, __LINE__, pc->text(), next->text()); - chunk_flags_set(pc, PCF_FORCE_SPACE); - } - // TODO: what is the meaning of 4 - else if ( !kw1 - && !kw2 - && (pc->len() < 4) - && (next->len() < 4)) - { - // We aren't dealing with keywords. concat and try punctuators - char buf[9]; - memcpy(buf, pc->text(), pc->len()); - memcpy(buf + pc->len(), next->text(), next->len()); - buf[pc->len() + next->len()] = 0; - - const chunk_tag_t *ct; - ct = find_punctuator(buf, cpd.lang_flags); - - if ( ct != nullptr - && (strlen(ct->tag) != pc->len())) - { - // punctuator parsed to a different size.. - - /* - * C++11 allows '>>' to mean '> >' in templates: - * some_func<vector<string>>(); - */ - // (C++11) Permit removal of the space between '>>' in 'foo<bar<int> >'. Note - // that sp_angle_shift cannot remove the space without this option. - if ( ( ( language_is_set(LANG_CPP) - && options::sp_permit_cpp11_shift()) - || (language_is_set(LANG_JAVA | LANG_CS | LANG_VALA | LANG_OC))) - && chunk_is_token(pc, CT_ANGLE_CLOSE) - && chunk_is_token(next, CT_ANGLE_CLOSE)) - { - // allow '>' and '>' to become '>>' - } - else if (strcmp(ct->tag, "[]") == 0) - { - // this is OK - } - else - { - LOG_FMT(LSPACE, "%s(%d): : pc->text() is %s, next->text() is %s\n", - __func__, __LINE__, pc->text(), next->text()); - chunk_flags_set(pc, PCF_FORCE_SPACE); - } - } - } - } - } - int min_sp; - LOG_FMT(LSPACE, "%s(%d): orig_line is %zu, orig_col is %zu, pc-text() '%s', type is %s\n", - __func__, __LINE__, pc->orig_line, pc->orig_col, pc->text(), get_token_name(pc->type)); - iarf_e av = do_space_ensured(pc, next, min_sp); - min_sp = max(1, min_sp); - - switch (av) - { - case IARF_FORCE: - column += min_sp; // add exactly the specified number of spaces - break; - - case IARF_ADD: - { - int delta = min_sp; - - if ( next->orig_col >= pc->orig_col_end - && pc->orig_col_end != 0) - { - // Keep the same relative spacing, minimum 1 - delta = next->orig_col - pc->orig_col_end; - - if (delta < min_sp) - { - delta = min_sp; - } - } - column += delta; - break; - } - - case IARF_REMOVE: - // the symbols will be back-to-back "a+3" - break; - - case IARF_IGNORE: - - // Keep the same relative spacing, if possible - if ( next->orig_col >= pc->orig_col_end - && pc->orig_col_end != 0) - { - column += next->orig_col - pc->orig_col_end; - } - else - { - // preserve the position if virtual brace - // Issue #1854 - if (chunk_is_token(pc, CT_VBRACE_OPEN)) - { - column = next->orig_col; - } - } - break; - - default: - // If we got here, something is wrong... - break; - } // switch - - if ( chunk_is_comment(next) - && chunk_is_newline(chunk_get_next(next)) - && column < next->orig_col) - { - /* - * do some comment adjustments if sp_before_tr_emb_cmt and - * sp_endif_cmt did not apply. - */ - // Add or remove space between #else or #endif and a trailing comment. - if ( ( options::sp_before_tr_emb_cmt() == IARF_IGNORE - || ( get_chunk_parent_type(next) != CT_COMMENT_END - && get_chunk_parent_type(next) != CT_COMMENT_EMBED)) - && ( options::sp_endif_cmt() == IARF_IGNORE - || ( pc->type != CT_PP_ELSE - && pc->type != CT_PP_ENDIF))) - { - if (options::indent_relative_single_line_comments()) - { - // Try to keep relative spacing between tokens - LOG_FMT(LSPACE, "%s(%d): <relative adj>", __func__, __LINE__); - LOG_FMT(LSPACE, "%s(%d): pc is '%s', pc->orig_col is %zu, next->orig_col is %zu, pc->orig_col_end is %zu\n", - __func__, __LINE__, pc->text(), - pc->orig_col, next->orig_col, pc->orig_col_end); - column = pc->column + (next->orig_col - pc->orig_col_end); - } - else - { - /* - * If there was a space, we need to force one, otherwise - * try to keep the comment in the same column. - */ - size_t col_min = pc->column + pc->len() + ((next->orig_prev_sp > 0) ? 1 : 0); - column = next->orig_col; - - if (column < col_min) - { - column = col_min; - } - LOG_FMT(LSPACE, "%s(%d): <relative set>", __func__, __LINE__); - } - } - } - next->column = column; - - LOG_FMT(LSPACE, " rule = %s @ %zu => %zu\n", - (av == IARF_IGNORE) ? "IGNORE" : - (av == IARF_ADD) ? "ADD" : - (av == IARF_REMOVE) ? "REMOVE" : "FORCE", - column - prev_column, next->column); - - if (restoreValues) // guy 2015-09-22 - { - restore_options_for_QT(); - } - } - pc = next; - - if (QT_SIGNAL_SLOT_found) - { - // flag the chunk for a second processing - chunk_flags_set(pc, PCF_IN_QT_MACRO); - } - } -} // space_text - - -void space_text_balance_nested_parens(void) -{ - LOG_FUNC_ENTRY(); - - chunk_t *first = chunk_get_head(); - - while (first != nullptr) - { - chunk_t *next = chunk_get_next(first); - - if (next == nullptr) - { - break; - } - - // if there are two successive opening parenthesis - if ( chunk_is_str(first, "(", 1) - && chunk_is_str(next, "(", 1)) - { - // insert a space between them - space_add_after(first, 1); - - // test after the closing parens Issue #1703 - chunk_t *closing = chunk_get_next_type(first, (c_token_t)(first->type + 1), first->level); - - if (closing->orig_col == closing->prev->orig_col_end) - { - space_add_after(closing->prev, 1); - } - } - else if ( chunk_is_str(first, ")", 1) - && chunk_is_str(next, ")", 1)) - { - // insert a space between the two closing parens - space_add_after(first, 1); - - // test after the opening parens Issue #1703 - chunk_t *opening = chunk_get_prev_type(next, (c_token_t)(next->type - 1), next->level); - - if (opening->orig_col_end == opening->next->orig_col) - { - space_add_after(opening, 1); - } - } - first = next; - } -} // space_text_balance_nested_parens - - -size_t space_needed(chunk_t *first, chunk_t *second) -{ - LOG_FUNC_ENTRY(); - LOG_FMT(LSPACE, "%s(%d)\n", __func__, __LINE__); - - int min_sp; - - switch (do_space_ensured(first, second, min_sp)) - { - case IARF_ADD: - case IARF_FORCE: - return(max(1, min_sp)); - - case IARF_REMOVE: - return(0); - - case IARF_IGNORE: - default: - return(second->orig_col > (first->orig_col + first->len())); - } -} - - -size_t space_col_align(chunk_t *first, chunk_t *second) -{ - LOG_FUNC_ENTRY(); - - LOG_FMT(LSPACE, "%s(%d): first->orig_line is %zu, orig_col is %zu, [%s/%s], text() '%s' <==>\n", - __func__, __LINE__, first->orig_line, first->orig_col, - get_token_name(first->type), get_token_name(get_chunk_parent_type(first)), - first->text()); - LOG_FMT(LSPACE, "%s(%d): second->orig_line is %zu, orig_col is %zu [%s/%s], text() '%s',", - __func__, __LINE__, second->orig_line, second->orig_col, - get_token_name(second->type), get_token_name(get_chunk_parent_type(second)), - second->text()); - log_func_stack_inline(LSPACE); - - int min_sp; - iarf_e av = do_space_ensured(first, second, min_sp); - - LOG_FMT(LSPACE, "%s(%d): av is %s\n", __func__, __LINE__, to_string(av)); - size_t coldiff; - - if (first->nl_count) - { - LOG_FMT(LSPACE, "%s(%d): nl_count is %zu, orig_col_end is %zu\n", __func__, __LINE__, first->nl_count, first->orig_col_end); - coldiff = first->orig_col_end - 1; - } - else - { - LOG_FMT(LSPACE, "%s(%d): len is %zu\n", __func__, __LINE__, first->len()); - coldiff = first->len(); - } - LOG_FMT(LSPACE, "%s(%d): => coldiff is %zu\n", __func__, __LINE__, coldiff); - - LOG_FMT(LSPACE, "%s(%d): => av is %s\n", __func__, __LINE__, - (av == IARF_IGNORE) ? "IGNORE" : - (av == IARF_ADD) ? "ADD" : - (av == IARF_REMOVE) ? "REMOVE" : "FORCE"); - - switch (av) - { - case IARF_ADD: - case IARF_FORCE: - coldiff++; - break; - - case IARF_REMOVE: - break; - - case IARF_IGNORE: // Issue #2064 - LOG_FMT(LSPACE, "%s(%d): => first->orig_line is %zu\n", __func__, __LINE__, first->orig_line); - LOG_FMT(LSPACE, "%s(%d): => second->orig_line is %zu\n", __func__, __LINE__, second->orig_line); - LOG_FMT(LSPACE, "%s(%d): => first->text() is '%s'\n", __func__, __LINE__, first->text()); - LOG_FMT(LSPACE, "%s(%d): => second->text() is '%s'\n", __func__, __LINE__, second->text()); - LOG_FMT(LSPACE, "%s(%d): => first->orig_col is %zu\n", __func__, __LINE__, first->orig_col); - LOG_FMT(LSPACE, "%s(%d): => second->orig_col is %zu\n", __func__, __LINE__, second->orig_col); - LOG_FMT(LSPACE, "%s(%d): => first->len() is %zu\n", __func__, __LINE__, first->len()); - - if ( first->orig_line == second->orig_line - && second->orig_col > (first->orig_col + first->len())) - { - coldiff++; - } - break; - - default: - // If we got here, something is wrong... - break; - } - LOG_FMT(LSPACE, "%s(%d): => coldiff is %zu\n", __func__, __LINE__, coldiff); - return(coldiff); -} // space_col_align - - -void space_add_after(chunk_t *pc, size_t count) -{ - LOG_FUNC_ENTRY(); - - chunk_t *next = chunk_get_next(pc); - - // don't add at the end of the file or before a newline - if ( next == nullptr - || chunk_is_newline(next)) - { - return; - } - - // Limit to 16 spaces - if (count > 16) - { - count = 16; - } - - // Two CT_SPACE in a row -- use the max of the two - if (chunk_is_token(next, CT_SPACE)) - { - if (next->len() < count) - { - while (next->len() < count) - { - next->str.append(' '); - } - } - return; - } - chunk_t sp; - - set_chunk_type(&sp, CT_SPACE); - sp.flags = pc->flags & PCF_COPY_FLAGS; - sp.str = " "; // 16 spaces - sp.str.resize(count); - sp.level = pc->level; - sp.brace_level = pc->brace_level; - sp.pp_level = pc->pp_level; - sp.column = pc->column + pc->len(); - sp.orig_line = pc->orig_line; - sp.orig_col = pc->orig_col; - - chunk_add_after(&sp, pc); -} // space_add_after |