diff options
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/space.cpp')
| -rw-r--r-- | debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/space.cpp | 4004 |
1 files changed, 4004 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/space.cpp b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/space.cpp new file mode 100644 index 00000000..ed85a4d3 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/src/space.cpp @@ -0,0 +1,4004 @@ +/** + * @file space.cpp + * Adds or removes inter-chunk spaces. + * + * Information + * "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-2023 + * @license GPL v2+ + */ + +#include "space.h" + +#include "add_space_table.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; + + +/** + * 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 *first, Chunk *second, iarf_e av); + + +bool token_is_within_trailing_return(Chunk *pc) +{ + // look back for '->' type is TRAILING_RET + // until CT_FPAREN_CLOSE + // or CT_FPAREN_OPEN is found + Chunk *prev = pc; + + while (prev->IsNotNullChunk()) + { + if (prev->Is(CT_TRAILING_RET)) + { + return(true); + } + else if ( prev->Is(CT_FPAREN_CLOSE) + || prev->Is(CT_FPAREN_OPEN) + || prev->Is(CT_SEMICOLON)) // Issue #4080 + { + return(false); + } + else + { + prev = prev->GetPrev(); + } + } + return(false); +} // token_is_within_trailing_return + + +/** + * 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 + * + * 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 *first, Chunk *second, int &min_sp) +{ + LOG_FUNC_ENTRY(); + + LOG_FMT(LSPACE, "%s(%d): orig line %zu, orig col %zu, first text '%s', type %s\n", + __func__, __LINE__, first->GetOrigLine(), first->GetOrigCol(), first->Text(), get_token_name(first->GetType())); + + min_sp = 1; + + if ( first->Is(CT_VBRACE_OPEN) + && first->GetPrev()->Is(CT_SPAREN_CLOSE) + && second->IsNot(CT_SEMICOLON)) + { + // Add or remove space after ')' of control statements. + log_rule("sp_after_sparen"); + return(options::sp_after_sparen()); + } + + if (first->Is(CT_SPAREN_CLOSE)) + { + if (second->Is(CT_VBRACE_OPEN)) + { + // Fix spacing between SPAREN_CLOSE and VBRACE_OPEN tokens as we don't want the default behavior (which is ADD). + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( options::sp_sparen_brace() == IARF_IGNORE + && second->Is(CT_BRACE_OPEN)) + { + // Do sp_after_sparen if sp_sparen_brace is ignored. No need for VBRACE_OPEN spacing. + log_rule("sp_after_sparen"); + return(options::sp_after_sparen()); + } + } + + if ( first->Is(CT_PP_IGNORE) + && second->Is(CT_PP_IGNORE)) + { + // Leave spacing alone between PP_IGNORE tokens as we don't want the default behavior (which is ADD). + log_rule("PP_IGNORE"); + return(IARF_IGNORE); + } + + if ( first->Is(CT_PP) + || second->Is(CT_PP)) + { + // Add or remove space around preprocessor '##' concatenation operator. + log_rule("sp_pp_concat"); + return(options::sp_pp_concat()); + } + + if (first->Is(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 ( second->Is(CT_POUND) + && second->TestFlags(PCF_IN_PREPROC) + && first->GetParentType() != 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 ( first->Is(CT_SPACE) + || second->Is(CT_SPACE)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (first->Is(CT_DECLSPEC)) // Issue 1289 + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( second->Is(CT_NEWLINE) + || second->Is(CT_VBRACE_OPEN)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( first->Is(CT_VBRACE_OPEN) + && second->IsNot(CT_NL_CONT) + && second->IsNot(CT_SEMICOLON)) // # Issue 1158 + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if ( first->Is(CT_VBRACE_CLOSE) + && second->IsNot(CT_NL_CONT)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (second->Is(CT_VSEMICOLON)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (first->Is(CT_MACRO_FUNC)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (second->Is(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 ( language_is_set(LANG_D) + && ( first->Is(CT_D_ARRAY_COLON) + || second->Is(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 ( first->Is(CT_CASE) + && (( CharTable::IsKw1(second->GetStr()[0]) + || second->Is(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 (first->Is(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 (second->Is(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 ( first->Is(CT_QUESTION) + && second->Is(CT_COND_COLON)) + { + // 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 ( first->Is(CT_QUESTION) // see the tests cpp:34513-34516 + || second->Is(CT_QUESTION)) + { + if ( second->Is(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 ( first->Is(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()); + } + log_rule("sp_cond_question"); + return(options::sp_cond_question()); + } + + if ( first->Is(CT_COND_COLON) + || second->Is(CT_COND_COLON)) + { + if ( second->Is(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 ( first->Is(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 (first->Is(CT_WORD) && second->Is(CT_COND_COLON))" + // Add or remove space around the ':' in 'b ? t : f'. + log_rule("sp_cond_colon"); + return(options::sp_cond_colon()); + } + + if ( language_is_set(LANG_D) + && ( first->Is(CT_RANGE) + || second->Is(CT_RANGE))) + { + // (D) Add or remove space around the D '..' operator. + log_rule("sp_range"); + return(options::sp_range()); + } + + if ( first->Is(CT_COLON) + && first->GetParentType() == CT_SQL_EXEC) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + // Macro stuff can only return IGNORE, ADD, or FORCE + if (first->Is(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 ( first->Is(CT_FPAREN_CLOSE) + && first->GetParentType() == 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 (first->Is(CT_PREPROC)) + { + // Remove spaces, unless we are ignoring. See indent_preproc() + log_rule("pp_space_after"); + + if (options::pp_space_after() == IARF_IGNORE) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (second->Is(CT_PREPROC)) + { + // Remove spaces, unless we are ignoring. See indent_preproc() + log_rule("pp_indent"); + + if (options::pp_indent() == IARF_IGNORE) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (second->Is(CT_SEMICOLON)) // see the tests cpp:34517-34519 + { + if (first->Is(CT_VBRACE_OPEN)) + { + // Add or remove space before ';'. + log_rule("sp_before_semi"); + return(options::sp_before_semi()); + } + + // Issue #4094-03 + if (second->GetParentType() == CT_FOR) + { + if (first->Is(CT_SPAREN_OPEN)) + { + // empty, e.g. for (;;) + // ^ is first + // ^ is second + // Add or remove space before a semicolon of an empty left part of a for statement. + log_rule("sp_before_semi_for_empty"); + return(options::sp_before_semi_for_empty()); + } + + if (first->Is(CT_SEMICOLON)) + { + // empty, e.g. for (;;) + // ^ is first + // ^ is second + // Add or remove space between semicolons of an empty middle part of a for statement. + log_rule("sp_between_semi_for_empty"); + return(options::sp_between_semi_for_empty()); + } + // 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(); // see the tests cpp:34517-34519 + + if ( first->Is(CT_VBRACE_OPEN) // Issue #2942 + && first->GetPrev()->Is(CT_SPAREN_CLOSE) + && first->GetParentType() != 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 ( ( second->Is(CT_COMMENT) + || second->Is(CT_COMMENT_CPP)) + && ( first->Is(CT_PP_ELSE) + || first->Is(CT_PP_ENDIF))) + { + if (second->Is(CT_COMMENT_CPP)) + { + second->SetType(CT_COMMENT_CPP_ENDIF); + } + else + { + second->SetType(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_cmt() != IARF_IGNORE + && second->GetParentType() == CT_COMMENT_END) + { + // Add or remove space before a trailing comment. + // Number of spaces before a trailing comment. + log_rule("sp_num_before_tr_cmt"); + min_sp = options::sp_num_before_tr_cmt(); + return(options::sp_before_tr_cmt()); + } + + if (second->GetParentType() == CT_COMMENT_END) + { + switch (second->GetOrigPrevSp()) + { + case 0: + log_rule("orig prev sp - REMOVE"); + return(IARF_REMOVE); + + case 1: + log_rule("orig prev sp - FORCE"); + return(IARF_FORCE); + + default: + log_rule("orig prev sp - ADD"); + return(IARF_ADD); + } + } + + // Issue #4094-05 + // "for (;;)" vs. "for (;; )" and "for (a;b;c)" vs. "for (a; b; c)" + if (first->Is(CT_SEMICOLON)) // see the tests cpp:34517-34519 + { + if (first->GetParentType() == CT_FOR) + { + if (second->Is(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 (second->IsNot(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 ( !second->IsComment() + && second->IsNot(CT_BRACE_CLOSE)) // issue #197 + { + // Add or remove space after ';', except when followed by a comment. + // see the tests cpp:34517-34519 + 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 ( ( first->Is(CT_NEG) + || first->Is(CT_POS) + || first->Is(CT_ARITH) + || first->Is(CT_SHIFT)) + && ( second->Is(CT_NEG) + || second->Is(CT_POS) + || second->Is(CT_ARITH) + || second->Is(CT_SHIFT))) + { + log_rule("ADD"); + return(IARF_ADD); + } + + // "return(a);" vs. "return (foo_t)a + 3;" vs. "return a;" vs. "return;" + if (first->Is(CT_RETURN)) + { + if ( second->Is(CT_PAREN_OPEN) + && second->GetParentType() == CT_RETURN) + { + // Add or remove space between 'return' and '('. + log_rule("sp_return_paren"); + return(options::sp_return_paren()); + } + else if ( second->Is(CT_BRACE_OPEN) + && second->GetParentType() == 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 + // The value REMOVE will be overridden with FORCE + log_rule("sp_return"); + + if (options::sp_return() == IARF_REMOVE) + { + return(IARF_FORCE); + } + return(options::sp_return()); + } + + // "sizeof(foo_t)" vs. "sizeof (foo_t)" + if (first->Is(CT_SIZEOF)) + { + if (second->Is(CT_PAREN_OPEN)) + { + // Add or remove space between 'sizeof' and '('. + log_rule("sp_sizeof_paren"); + return(options::sp_sizeof_paren()); + } + + if (second->Is(CT_ELLIPSIS)) + { + // Add or remove space between 'sizeof' and '...'. + log_rule("sp_sizeof_ellipsis"); + return(options::sp_sizeof_ellipsis()); + } + log_rule("FORCE"); + return(IARF_FORCE); + } + + // "decltype(foo_t)" vs. "decltype (foo_t)" + if (first->Is(CT_DECLTYPE)) + { + if (second->Is(CT_PAREN_OPEN)) + { + // Add or remove space between 'decltype' and '('. + log_rule("sp_decltype_paren"); + return(options::sp_decltype_paren()); + } + log_rule("FORCE"); + return(IARF_FORCE); + } + + // handle '::' + if (first->Is(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 ( first->Is(CT_PAREN_CLOSE) + && second->Is(CT_DC_MEMBER) + && second->GetNext()->GetType() == CT_FUNC_CALL) + { + log_rule("sp_after_cast"); + return(options::sp_after_cast()); + } + + if (second->Is(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->GetType()) + { + 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("FORCE"); + return(IARF_FORCE); + + default: + break; + } + + if ( ( first->Is(CT_WORD) + || first->Is(CT_TYPE) + || first->Is(CT_PAREN_CLOSE) + || CharTable::IsKw1(first->GetStr()[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 (first->Is(CT_COMMA)) // see the tests cpp:34520-34524 + // see the tests c-sharp:12200-12202 + { + if ( language_is_set(LANG_CS | LANG_VALA) + && first->GetParentType() == CT_TYPE) + { + // (C#, Vala) multidimensional array type: ',,' vs. ', ,' or ',]' vs. ', ]' + if (second->Is(CT_COMMA)) + { + // (C#, Vala) Add or remove space between ',' in multidimensional array type + // like 'int[,,]'. + log_rule("sp_between_mdatype_commas"); + return(options::sp_between_mdatype_commas()); + } + // (C#, Vala) 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 (second->Is(CT_ANGLE_CLOSE)) + { + log_rule("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 ( first->Is(CT_FPAREN_CLOSE) + && ( second->Is(CT_FPAREN_CLOSE) + || second->Is(CT_COMMA))) + { + if (second->GetLevel() == QT_SIGNAL_SLOT_level) + { + restoreValues = true; + } + } + } + + if (second->Is(CT_COMMA)) + { + if ( language_is_set(LANG_CS | LANG_VALA) + && first->Is(CT_SQUARE_OPEN) + && first->GetParentType() == CT_TYPE) + { + // (C#, Vala) 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 ( first->Is(CT_PAREN_OPEN) + || first->Is(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 ',', i.e. 'a,b' vs. 'a ,b'. + log_rule("sp_before_comma"); + return(options::sp_before_comma()); + } + + if (second->Is(CT_ELLIPSIS)) + { + // type followed by a ellipsis + Chunk *tmp = first; + + if ( tmp->Is(CT_PTR_TYPE) + || tmp->Is(CT_BYREF)) + { + tmp = tmp->GetPrevNcNnl(); + } + + if ( tmp->Is(CT_TYPE) + || tmp->Is(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->TestFlags(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 ( first->Is(CT_FPAREN_CLOSE) + || first->Is(CT_PAREN_CLOSE)) + { + // Add or remove space between ')' and '...'. + log_rule("sp_paren_ellipsis"); + return(options::sp_paren_ellipsis()); + } + + if (first->Is(CT_TAG_COLON)) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if (first->Is(CT_BYREF)) // Issue #3309 + { + log_rule("sp_byref_ellipsis"); + return(options::sp_byref_ellipsis()); + } + + if (first->Is(CT_PARAMETER_PACK)) // Issue #3309 + { + log_rule("sp_parameter_pack_ellipsis"); + return(options::sp_parameter_pack_ellipsis()); + } + } + + if (first->Is(CT_ELLIPSIS)) + { + if (second->Is(CT_PARAMETER_PACK)) // Issue #3309 + { + log_rule("sp_ellipsis_parameter_pack"); + return(options::sp_ellipsis_parameter_pack()); + } + + if (CharTable::IsKw1(second->GetStr()[0])) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if ( second->Is(CT_PAREN_OPEN) + && first->GetPrev()->Is(CT_SIZEOF)) + { + // Add or remove space between 'sizeof...' and '('. + log_rule("sp_sizeof_ellipsis_paren"); + return(options::sp_sizeof_ellipsis_paren()); + } + } + + if ( language_is_set(LANG_PAWN) + && first->Is(CT_TAG_COLON)) + { + // (Pawn) Add or remove space after the tag keyword. + log_rule("sp_after_tag"); + return(options::sp_after_tag()); + } + + if (second->Is(CT_TAG_COLON)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + // handle '~' + if (first->Is(CT_DESTRUCTOR)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( language_is_set(LANG_OC) + && first->Is(CT_CATCH) + && second->Is(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) + && ( first->Is(CT_PAREN_CLOSE) + || first->Is(CT_OC_CLASS) + || first->Is(CT_WORD)) + && second->Is(CT_ANGLE_OPEN) + && ( second->GetParentType() == CT_OC_PROTO_LIST + || second->GetParentType() == 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) + && first->Is(CT_OC_CLASS) + && second->Is(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 ( first->Is(CT_CATCH) + && second->Is(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 ( language_is_set(LANG_D) + && first->Is(CT_D_VERSION_IF) + && second->Is(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 ( language_is_set(LANG_D) + && first->Is(CT_D_SCOPE_IF) + && second->Is(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) + && first->Is(CT_SYNCHRONIZED) + && second->Is(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 (second->Is(CT_SPAREN_OPEN)) + { + // Add or remove space after 'do' between 'while' and '('. Issue #995 + if ( first->Is(CT_WHILE_OF_DO) + && options::sp_while_paren_open() != IARF_IGNORE) + { + log_rule("sp_while_paren_open"); + return(options::sp_while_paren_open()); + } + // Add or remove space before '(' of other control statements ('if', 'for', + // 'switch', 'while', etc.). + log_rule("sp_before_sparen"); + return(options::sp_before_sparen()); + } + + if ( first->Is(CT_LAMBDA) + || second->Is(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) + && ( ( first->Is(CT_SQUARE_OPEN) + && first->GetParentType() == CT_CPP_LAMBDA + && second->Is(CT_ASSIGN)) + || ( first->Is(CT_ASSIGN) + && second->Is(CT_SQUARE_CLOSE) + && second->GetParentType() == CT_CPP_LAMBDA))) + { + log_rule("sp_cpp_lambda_assign"); + return(options::sp_cpp_lambda_assign()); + } + + if ( first->Is(CT_SQUARE_CLOSE) + && first->GetParentType() == 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 (second->Is(CT_LPAREN_OPEN)) + { + log_rule("sp_cpp_lambda_square_paren"); + return(options::sp_cpp_lambda_square_paren()); + } + else if (second->Is(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 (first->Is(CT_LPAREN_OPEN)) + { + if (second->Is(CT_LPAREN_CLOSE)) + { + // Add or remove space after the opening parenthesis and before the closing + // parenthesis of a argument list of a C++11 lambda, as in + // '[]( <here> ){ ... }' + // with an empty list. + log_rule("sp_cpp_lambda_argument_list_empty"); + return(options::sp_cpp_lambda_argument_list_empty()); + } + // 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 (first->Is(CT_LPAREN_CLOSE)) + { + if (second->Is(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 (second->Is(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 ( first->Is(CT_BRACE_CLOSE) + && first->GetParentType() == CT_CPP_LAMBDA + && second->Is(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 (first->Is(CT_ENUM)) + { + if (second->Is(CT_BRACE_OPEN)) + { + // Add or remove space in 'enum {'. + log_rule("sp_enum_brace"); + return(options::sp_enum_brace()); + } + else if (second->Is(CT_FPAREN_OPEN)) + { + // Add or remove space in 'NS_ENUM ('. + log_rule("sp_enum_paren"); + return(options::sp_enum_paren()); + } + } + + if (second->Is(CT_ASSIGN)) + { + if (second->TestFlags(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) + && second->GetParentType() == 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 (second->Is(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) + && second->GetParentType() == 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 (first->Is(CT_ASSIGN)) + { + if (first->TestFlags(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) + && first->GetParentType() == 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 ( first->Is(CT_TRAILING_RET) + || first->Is(CT_CPP_LAMBDA_RET) + || second->Is(CT_TRAILING_RET) + || second->Is(CT_CPP_LAMBDA_RET)) + { + // Add or remove space around trailing return operator '->'. + log_rule("sp_trailing_return"); + return(options::sp_trailing_return()); + } + + if (first->Is(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) + && first->GetParentType() == 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 (first->Is(CT_ENUM_COLON)) // Issue #4040 + { + // Add or remove space around assignment ':' in enum. + log_rule("sp_enum_colon"); + return(options::sp_enum_colon()); + } + + if (second->Is(CT_ENUM_COLON)) // Issue #4040 + { + // Add or remove space around assignment ':' in enum. + log_rule("sp_enum_colon"); + return(options::sp_enum_colon()); + } + + if (first->Is(CT_BIT_COLON)) // Issue #4040 + { + // Add or remove space after a bit colon ':'. + log_rule("sp_after_bit_colon"); + return(options::sp_after_bit_colon()); + } + + if (second->Is(CT_BIT_COLON)) // Issue #4040 + { + // Add or remove space before a bit colon ':'. + log_rule("sp_before_bit_colon"); + return(options::sp_before_bit_colon()); + } + + if ( first->Is(CT_OC_AVAILABLE_VALUE) + || second->Is(CT_OC_AVAILABLE_VALUE)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + + if (language_is_set(LANG_OC)) + { + if (second->Is(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 (first->Is(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 (second->Is(CT_OC_MSG_FUNC)) + { + if ( (options::sp_after_oc_msg_receiver() == IARF_REMOVE) + && ( first->IsNot(CT_SQUARE_CLOSE) + && first->IsNot(CT_FPAREN_CLOSE) + && first->IsNot(CT_PAREN_CLOSE))) + { + log_rule("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) + && ( first->Is(CT_BYREF) + || first->Is(CT_QUALIFIER) + || first->Is(CT_TYPE)) + && second->Is(CT_SQUARE_OPEN) + && second->GetParentType() != CT_OC_MSG + && second->GetParentType() != 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 ( second->Is(CT_SQUARE_OPEN) + && ( second->GetParentType() != CT_OC_MSG + && second->GetParentType() != CT_CS_SQ_STMT + && second->GetParentType() != CT_CPP_LAMBDA)) + { + if ( second->TestFlags(PCF_IN_SPAREN) + && (first->Is(CT_IN))) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if (first->Is(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->TestFlags(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 (second->Is(CT_TSQUARE)) + { + // Add or remove space before '[]'. + log_rule("sp_before_squares"); + return(options::sp_before_squares()); + } + + if ( (options::sp_angle_shift() != IARF_IGNORE) + && first->Is(CT_ANGLE_CLOSE) + && second->Is(CT_ANGLE_CLOSE)) + { + // Add or remove space between '>' and '>' in '>>' (template stuff). + log_rule("sp_angle_shift"); + return(options::sp_angle_shift()); + } + + // Issue #4094-01 + // spacing around template < > stuff + if ( first->Is(CT_ANGLE_OPEN) + || second->Is(CT_ANGLE_CLOSE)) + { + if ( first->Is(CT_ANGLE_OPEN) + && second->Is(CT_ANGLE_CLOSE)) + { + // Add or remove space inside '<>'. + // if empty. + 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() + && first->Is(CT_ANGLE_OPEN) + && second->Is(CT_DC_MEMBER)) + { + op = IARF_IGNORE; + } + return(op); + } + + if (second->Is(CT_ANGLE_OPEN)) + { + if ( first->Is(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->IsNot(CT_QUALIFIER)) + { + // Add or remove space before '<'. + log_rule("sp_before_angle"); + return(options::sp_before_angle()); + } + } + + if (first->Is(CT_ANGLE_CLOSE)) + { + if ( second->Is(CT_WORD) + || CharTable::IsKw1(second->GetStr()[0])) + { + // Add or remove space between '>' and a word as in 'List<byte> m;' or + // 'template <typename T> static ...'. + log_rule("sp_angle_word"); + return(options::sp_angle_word()); + } + + // Issue #4094-02 + if ( second->Is(CT_FPAREN_OPEN) + || second->Is(CT_PAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(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 (second->Is(CT_DC_MEMBER)) + { + // Add or remove space before the '::' operator. + log_rule("sp_before_dc"); + return(options::sp_before_dc()); + } + + if ( second->IsNot(CT_BYREF) + && second->IsNot(CT_PTR_TYPE) + && second->IsNot(CT_BRACE_OPEN) + && second->IsNot(CT_PAREN_CLOSE)) + { + if ( second->Is(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 ( second->Is(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 (first->Is(CT_BYREF)) // see the tests cpp:34509-34512 + { + if (second->Is(CT_PAREN_OPEN)) + { + // Add or remove space after a reference sign '&', if followed by an open + // parenthesis, as in 'char& (*)()'. + log_rule("sp_byref_paren"); + return(options::sp_byref_paren()); + } + else if ( first->GetParentType() == CT_FUNC_DEF // Issue #3197, #3210 + || first->GetParentType() == 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"); // byref 2 + return(options::sp_after_byref_func()); + } + else if ( CharTable::IsKw1(second->GetStr()[0]) + && ( options::sp_after_byref() != IARF_IGNORE + || ( !second->Is(CT_FUNC_PROTO) + && !second->Is(CT_FUNC_DEF)))) + { + // Add or remove space after reference sign '&', if followed by a word. + log_rule("sp_after_byref"); // byref 1 + return(options::sp_after_byref()); + } + } + + if ( second->Is(CT_BYREF) + && !first->Is(CT_PAREN_OPEN)) // Issue #1804 + { + if ( second->GetParentType() == CT_FUNC_DEF // Issue #3197, #3210 + || second->GetParentType() == CT_FUNC_PROTO) + { + // Add or remove space before a reference sign '&', if followed by a function + // prototype or function definition. + log_rule("sp_before_byref_func"); // byref 4 + return(options::sp_before_byref_func()); + } + Chunk *next = second->GetNext(); + + if ( next->IsNotNullChunk() + && ( next->Is(CT_COMMA) + || next->Is(CT_PAREN_CLOSE) // Issue #3691 + || next->Is(CT_FPAREN_CLOSE) + || next->Is(CT_SEMICOLON))) + { + if (options::sp_before_unnamed_byref() != IARF_IGNORE) // Issue #3691 + { + // 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. + log_rule("sp_before_unnamed_byref"); // byref 5 + return(options::sp_before_unnamed_byref()); + } + else + { + // Add or remove space before a reference sign '&'. + log_rule("sp_before_byref"); // byref 3 + return(options::sp_before_byref()); + } + } + + if (first->Is(CT_PTR_TYPE)) + { + // Add or remove space between pointer and Ref. + // as in 'int *& a'. + log_rule("sp_between_ptr_ref"); // ptr_ref 1 + return(options::sp_between_ptr_ref()); + } + // Add or remove space before a reference sign '&'. + log_rule("sp_before_byref"); // byref 3 + return(options::sp_before_byref()); + } + + if (first->Is(CT_SPAREN_CLOSE)) + { + if (second->Is(CT_BRACE_OPEN)) + { + if (second->GetParentType() == 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 control statements. + log_rule("sp_sparen_brace"); + return(options::sp_sparen_brace()); + } + } + } + + // Issue #4094-07 + if ( second->Is(CT_FPAREN_OPEN) + && first->GetParentType() == CT_OPERATOR + && (options::sp_after_operator_sym() != IARF_IGNORE)) + { + if ( (options::sp_after_operator_sym_empty() != IARF_IGNORE) + && second->Is(CT_FPAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(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) + && first->Is(CT_FUNC_CALL)) + { + if ( first->IsString("_") + && second->Is(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 ( first->Is(CT_MACRO_OPEN) + || first->Is(CT_MACRO_CLOSE) + || first->Is(CT_MACRO_ELSE)) + { + if (second->Is(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("IGNORE"); + return(IARF_IGNORE); + } + + // Issue #4094-11 + // spaces between function and open paren + if ( first->Is(CT_FUNC_CALL) + || first->Is(CT_FUNCTION) // Issue #2665 + || first->Is(CT_FUNC_CTOR_VAR) + || first->Is(CT_CNG_HASINC) + || first->Is(CT_CNG_HASINCN) + || ( first->Is(CT_BRACE_CLOSE) + && first->GetParentType() == CT_BRACED_INIT_LIST + && second->Is(CT_FPAREN_OPEN)) + || ( first->Is(CT_FUNC_VAR) // Issue #3852 + && second->Is(CT_PAREN_OPEN))) + { + if ( (options::sp_func_call_paren_empty() != IARF_IGNORE) + && second->Is(CT_FPAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(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 (first->Is(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 ( first->Is(CT_ATTRIBUTE) + && second->IsParenOpen()) + { + // Add or remove space between '__attribute__' and '('. + log_rule("sp_attribute_paren"); + return(options::sp_attribute_paren()); + } + + // Issue #4094-10 + if (first->Is(CT_FUNC_DEF)) + { + if ( (options::sp_func_def_paren_empty() != IARF_IGNORE) + && second->Is(CT_FPAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(CT_FPAREN_CLOSE)) + { + // Add or remove space between function name and '()' on function definition + // if empty. + 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 ( first->Is(CT_CPP_CAST) + || first->Is(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 ( first->Is(CT_SPAREN_CLOSE) + && second->Is(CT_WHEN)) + { + // TODO: provide some test data to check this block + log_rule("FORCE"); + return(IARF_FORCE); // TODO: make this configurable? + } + + if ( first->Is(CT_PAREN_CLOSE) + && ( second->Is(CT_PAREN_OPEN) + || second->Is(CT_FPAREN_OPEN))) + { + // "(int)a" vs. "(int) a" or "cast(int)a" vs. "cast(int) a" + if ( first->GetParentType() == CT_C_CAST + || first->GetParentType() == 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()); + } + // Probably a parenthesized indirect function call or similar (issue #3260) + log_rule("sp_cparen_oparen"); + return(options::sp_cparen_oparen()); + } + + // handle the space between parens in fcn type 'void (*f)(void)' + if (first->Is(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 ( ( first->IsString(")") + && second->IsString("(")) + || ( first->IsParenClose() + && second->IsParenOpen())) + { + // Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('. + log_rule("sp_cparen_oparen"); + return(options::sp_cparen_oparen()); + } + + // Issue #4094-09 + if ( first->Is(CT_FUNC_PROTO) + || ( second->Is(CT_FPAREN_OPEN) + && second->GetParentType() == CT_FUNC_PROTO)) + { + if ( (options::sp_func_proto_paren_empty() != IARF_IGNORE) + && second->Is(CT_FPAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(CT_FPAREN_CLOSE)) + { + // Add or remove space between function name and '()' on function declaration + // if empty. + 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 ( first->Is(CT_FUNC_TYPE) + && second->Is(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()); + } + + // Issue #4094-12 + if ( first->Is(CT_FUNC_CLASS_DEF) + || first->Is(CT_FUNC_CLASS_PROTO)) + { + if ( (options::sp_func_class_paren_empty() != IARF_IGNORE) + && second->Is(CT_FPAREN_OPEN)) + { + Chunk *next = second->GetNextNcNnl(); + + if (next->Is(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 ( first->Is(CT_CLASS) + && !first->TestFlags(PCF_IN_OC_MSG)) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + // Issue #4094-08 + if ( first->Is(CT_BRACE_OPEN) + && second->Is(CT_BRACE_CLOSE)) + { + // Add or remove space inside '{}'. + // if empty. + log_rule("sp_inside_braces_empty"); + return(options::sp_inside_braces_empty()); + } + + if ( ( first->Is(CT_TYPE) // Issue #2428 + || first->Is(CT_ANGLE_CLOSE)) + && second->Is(CT_BRACE_OPEN) + && second->GetParentType() == CT_BRACED_INIT_LIST) + { + iarf_flags_t arg = iarf_flags_t{ options::sp_type_brace_init_lst() }; + + if ( arg != IARF_IGNORE + || first->GetParentType() != 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 ( ( first->Is(CT_WORD) // Issue #2428 + || first->Is(CT_SQUARE_CLOSE) + || first->Is(CT_TSQUARE)) + && second->Is(CT_BRACE_OPEN) + && second->GetParentType() == 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 + || first->GetParentType() != 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 (second->Is(CT_BRACE_CLOSE)) + { + if (second->GetParentType() == CT_ENUM) + { + // Add or remove space inside enum '{' and '}'. + log_rule("sp_inside_braces_enum"); + return(options::sp_inside_braces_enum()); + } + + if ( second->GetParentType() == CT_STRUCT + || second->GetParentType() == CT_UNION) + { + // Fix for issue #1240 adding space in struct initializers + Chunk *tmp = second->GetOpeningParen()->GetPrevNcNnl(); + + if (tmp->Is(CT_ASSIGN)) + { + // TODO: provide some test data to check this block + log_rule("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 ( language_is_set(LANG_OC) + && second->GetParentType() == 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 (second->GetParentType() == 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 + && first->Is(CT_BRACE_CLOSE) + && first->GetParentType() == 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 + // if statement is a brace_init_lst + // works only if sp_brace_brace is set to ignore. + 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. + // if statement is a brace_init_lst + // works only if sp_brace_brace is set to ignore + // works only if sp_before_type_brace_init_lst_close is set to ignore. + 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 (first->Is(CT_D_CAST)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( first->Is(CT_PP_DEFINED) + && second->Is(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 (first->Is(CT_THROW)) + { + if (second->Is(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 ( first->Is(CT_THIS) + && second->Is(CT_PAREN_OPEN)) + { + // Add or remove space between 'this' and '(' in 'this (something)'. + log_rule("sp_this_paren"); + return(options::sp_this_paren()); + } + + if ( first->Is(CT_STATE) + && second->Is(CT_PAREN_OPEN)) + { + log_rule("ADD"); + return(IARF_ADD); + } + + if ( first->Is(CT_DELEGATE) + && second->Is(CT_PAREN_OPEN)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( first->Is(CT_MEMBER) + || second->Is(CT_MEMBER)) + { + // Add or remove space around the '.' or '->' operators. + log_rule("sp_member"); + return(options::sp_member()); + } + + if (first->Is(CT_C99_MEMBER)) + { + // always remove space(s) after then '.' of a C99-member + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( first->Is(CT_SUPER) + && second->Is(CT_PAREN_OPEN)) + { + // Add or remove space between 'super' and '(' in 'super (something)'. + log_rule("sp_super_paren"); + return(options::sp_super_paren()); + } + + if ( first->Is(CT_FPAREN_CLOSE) + && second->Is(CT_BRACE_OPEN)) + { + if ( language_is_set(LANG_JAVA) + && second->GetParentType() == 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 (first->GetParentType() == CT_FUNC_CALL) + { + Chunk *tmp = first->GetPrevType(first->GetParentType(), first->GetLevel()); + tmp = tmp->GetPrevNcNnl(); + + if (tmp->Is(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 ( first->Is(CT_D_TEMPLATE) + || second->Is(CT_D_TEMPLATE)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if ( first->Is(CT_ELSE) + && second->Is(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 ( first->Is(CT_ELSE) + && second->Is(CT_ELSEIF)) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if ( first->Is(CT_FINALLY) + && second->Is(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 ( first->Is(CT_TRY) + && second->Is(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 ( first->Is(CT_GETSET) + && second->Is(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 ( first->Is(CT_WORD) + && second->Is(CT_BRACE_OPEN)) + { + if (first->GetParentType() == 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 ( language_is_set(LANG_D) + && second->Is(CT_PAREN_OPEN) + && second->GetParentType() == CT_INVARIANT) + { + // (D) Add or remove space between 'invariant' and '('. + log_rule("sp_invariant_paren"); + return(options::sp_invariant_paren()); + } + + if ( first->Is(CT_PAREN_CLOSE) + && first->GetParentType() != CT_DECLTYPE) + { + if ( language_is_set(LANG_D) + && first->GetParentType() == 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 (second->Is(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 (first->GetParentType() == CT_DELEGATE) + { + log_rule("ADD"); + return(IARF_ADD); + } + + // PAWN-specific: "state (condition) next" + if (first->GetParentType() == CT_STATE) + { + log_rule("ADD"); + return(IARF_ADD); + } + + /* C++ new operator: new(bar) Foo */ + if (first->GetParentType() == 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 ( ( first->IsString("(") + && second->IsString("(")) + || ( first->IsString(")") + && second->IsString(")"))) + { + if (second->GetParentType() == 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()); + } + + if ( options::sp_sparen_paren() != IARF_IGNORE + && ( first->Is(CT_SPAREN_OPEN) + || second->Is(CT_SPAREN_CLOSE))) + { + // Add or remove space between nested parentheses with control + // statements, i.e. 'if ((' vs. 'if ( ('. Issue #3209 + log_rule("sp_sparen_paren"); + return(options::sp_sparen_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 ( first->Is(CT_FPAREN_OPEN) + || second->Is(CT_FPAREN_CLOSE)) + { + if ( (first->GetParentType() == CT_FUNC_CALL_USER) + || ( (second->GetParentType() == CT_FUNC_CALL_USER) + && ( (first->Is(CT_WORD)) + || (first->Is(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 ( first->Is(CT_FPAREN_OPEN) + && second->Is(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()); + } + + // functor "foo(...)" vs. "foo( ... )" + if ( first->Is(CT_RPAREN_OPEN) + || second->Is(CT_RPAREN_CLOSE)) // Issue #3914 + { + if ( (first->GetParentType() == CT_FUNC_CALL_USER) + || ( (second->GetParentType() == CT_FUNC_CALL_USER) + && ( (first->Is(CT_WORD)) + || (first->Is(CT_SQUARE_CLOSE))))) + { + // Add or remove space inside user function '(' and ')'. + log_rule("sp_func_call_user_inside_rparen"); + return(options::sp_func_call_user_inside_rparen()); + } + + if ( first->Is(CT_RPAREN_OPEN) + && second->Is(CT_RPAREN_CLOSE)) // Issue #3914 + { + // Add or remove space inside empty function '()'. + log_rule("sp_inside_rparens"); + return(options::sp_inside_rparens()); + } + // Add or remove space inside function '(' and ')'. + log_rule("sp_inside_rparen"); + return(options::sp_inside_rparen()); + } + + // "foo(...)" vs. "foo( ... )" + if ( first->Is(CT_TPAREN_OPEN) + || second->Is(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 ( language_is_set(LANG_OC) + && first->Is(CT_PAREN_CLOSE)) + { + if ( first->TestFlags(PCF_OC_RTYPE) // == CT_OC_RTYPE) + && ( first->GetParentType() == CT_OC_MSG_DECL + || first->GetParentType() == 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 ( first->GetParentType() == CT_OC_MSG_SPEC + || first->GetParentType() == 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 ( first->GetParentType() == CT_OC_SEL + && second->IsNot(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 ( language_is_set(LANG_OC) + && options::sp_inside_oc_at_sel_parens() != IARF_IGNORE) + { + if ( ( first->Is(CT_PAREN_OPEN) + && ( first->GetParentType() == CT_OC_SEL + || first->GetParentType() == CT_OC_PROTOCOL)) + || ( second->Is(CT_PAREN_CLOSE) + && ( second->GetParentType() == CT_OC_SEL + || second->GetParentType() == 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 ( second->Is(CT_PAREN_OPEN) + && ( first->Is(CT_OC_SEL) + || first->Is(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 (first->Is(CT_PAREN_OPEN)) + { + if ( first->GetParentType() == CT_C_CAST + || first->GetParentType() == CT_CPP_CAST + || first->GetParentType() == CT_D_CAST) + { + // Add or remove spaces inside cast parentheses. + log_rule("sp_inside_paren_cast"); + return(options::sp_inside_paren_cast()); + } + + if (first->GetParentType() == 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 parentheses 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 (second->Is(CT_PAREN_CLOSE)) + { + if ( second->GetParentType() == CT_C_CAST + || second->GetParentType() == CT_CPP_CAST + || second->GetParentType() == CT_D_CAST) + { + // Add or remove spaces inside cast parentheses. + log_rule("sp_inside_paren_cast"); + return(options::sp_inside_paren_cast()); + } + + if (second->GetParentType() == 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 parentheses 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()); + } + + // Issue #4094-06 + if ( first->Is(CT_SQUARE_OPEN) + && second->Is(CT_SQUARE_CLOSE)) + { + // Add or remove space inside '[]'. + // if empty. + log_rule("sp_inside_square_empty"); + return(options::sp_inside_square_empty()); + } + + // "[3]" vs. "[ 3 ]" or for objective-c "@[@3]" vs. "@[ @3 ]" + if ( first->Is(CT_SQUARE_OPEN) + || second->Is(CT_SQUARE_CLOSE)) + { + if ( language_is_set(LANG_OC) + && ( ( first->GetParentType() == CT_OC_AT + && first->Is(CT_SQUARE_OPEN)) + || ( second->GetParentType() == CT_OC_AT + && second->Is(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 ( first->Is(CT_SQUARE_CLOSE) + && second->Is(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( ... )" etc. + if (second->Is(CT_SPAREN_CLOSE)) + { + if ( second->GetParentType() == CT_FOR + && options::sp_inside_for_open() != IARF_IGNORE) + { + // Add or remove space before ')' of 'for' statements. + // Overrides sp_inside_for. + log_rule("sp_inside_for_close"); + return(options::sp_inside_for_close()); + } + else if (options::sp_inside_sparen_open() != IARF_IGNORE) + { + // Add or remove space before ')' of other control statements. + // Overrides sp_inside_sparen. + log_rule("sp_inside_sparen_close"); + return(options::sp_inside_sparen_close()); + } + } + + if (first->Is(CT_SPAREN_OPEN)) + { + if ( first->GetParentType() == CT_FOR + && options::sp_inside_for_open() != IARF_IGNORE) + { + // Add or remove space before ')' of 'for' statements. + // Overrides sp_inside_for. + log_rule("sp_inside_for_close"); + return(options::sp_inside_for_close()); + } + else if (options::sp_inside_sparen_open() != IARF_IGNORE) + { + // Add or remove space after '(' of other control statements. + // Overrides sp_inside_sparen. + log_rule("sp_inside_sparen_open"); + return(options::sp_inside_sparen_open()); + } + } + + if (first->Is(CT_SPAREN_OPEN)) + { + if (first->GetParentType() == CT_FOR) + { + // Add or remove space inside '(' and ')' of 'for' statements. + log_rule("sp_inside_for"); + return(options::sp_inside_for()); + } + else + { + // Add or remove space inside '(' and ')' of other control statements. + log_rule("sp_inside_sparen"); + return(options::sp_inside_sparen()); + } + } + + if (second->Is(CT_SPAREN_CLOSE)) + { + if (second->GetParentType() == CT_FOR) + { + // Add or remove space inside '(' and ')' of 'for' statements. + log_rule("sp_inside_for"); + return(options::sp_inside_for()); + } + else + { + // Add or remove space inside '(' and ')' of other control statements. + log_rule("sp_inside_sparen"); + return(options::sp_inside_sparen()); + } + } + + if (first->Is(CT_CLASS_COLON)) + { + if ( first->GetParentType() == CT_OC_CLASS + && ( first->GetPrevType(CT_OC_INTF, first->GetLevel(), E_Scope::ALL)->IsNullChunk() + && first->GetPrevType(CT_OC_IMPL, first->GetLevel(), E_Scope::ALL)->IsNullChunk())) + { + 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 (second->Is(CT_CLASS_COLON)) + { + if ( language_is_set(LANG_OC) + && second->GetParentType() == CT_OC_CLASS + && ( second->GetPrevType(CT_OC_INTF, second->GetLevel(), E_Scope::ALL)->IsNullChunk() + && second->GetPrevType(CT_OC_IMPL, second->GetLevel(), E_Scope::ALL)->IsNullChunk())) + { + if ( second->GetParentType() == CT_OC_CLASS + && second->GetPrevType(CT_OC_INTF, second->GetLevel(), E_Scope::ALL)->IsNullChunk()) + { + 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 (first->Is(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 (second->Is(CT_CONSTR_COLON)) + { + // Add or remove space before class constructor ':'. + log_rule("sp_before_constr_colon"); + return(options::sp_before_constr_colon()); + } + + if (second->Is(CT_CASE_COLON)) + { + // Add or remove space before case ':'. + log_rule("sp_before_case_colon"); + return(options::sp_before_case_colon()); + } + + if (first->Is(CT_DOT)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (second->Is(CT_DOT)) + { + log_rule("ADD"); + return(IARF_ADD); + } + + if ( first->Is(CT_NULLCOND) + || second->Is(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 ( first->Is(CT_ARITH) + || first->Is(CT_SHIFT) + || first->Is(CT_CARET) + || second->Is(CT_ARITH) + || second->Is(CT_SHIFT) + || second->Is(CT_CARET)) + { + // Add or remove space around arithmetic operators '+' and '-'. + // Overrides sp_arith. + if (options::sp_arith_additive() != IARF_IGNORE) + { + auto arith_char = ( first->Is(CT_ARITH) + || first->Is(CT_SHIFT) + || first->Is(CT_CARET)) + ? first->GetStr()[0] : second->GetStr()[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 ( first->Is(CT_BOOL) + || second->Is(CT_BOOL)) + { + // Add or remove space around boolean operators '&&' and '||'. + iarf_e arg = options::sp_bool(); + + if ( (options::pos_bool() != TP_IGNORE) + && first->GetOrigLine() != second->GetOrigLine()) + { + arg = arg | IARF_ADD; + } + log_rule("sp_bool"); + return(arg); + } + + if ( first->Is(CT_COMPARE) + || second->Is(CT_COMPARE)) + { + // Add or remove space around compare operator '<', '>', '==', etc. + log_rule("sp_compare"); + return(options::sp_compare()); + } + + if ( first->Is(CT_PAREN_OPEN) + && second->Is(CT_PTR_TYPE)) + { + // TODO: provide some test data to check this block + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (first->Is(CT_PTR_TYPE)) // see the tests cpp:34505-34508 + { + if ( second->Is(CT_FPAREN_OPEN) + || second->Is(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"); // ptr_star 10 + return(options::sp_ptr_star_paren()); + } + else if (second->Is(CT_PTR_TYPE)) + { + // Add or remove space between pointer stars '*'. + // as in 'int ***a;'. + log_rule("sp_between_ptr_star"); // ptr_star 9 + return(options::sp_between_ptr_star()); + } + else if (second->Is(CT_BYREF)) + { + // Add or remove space between pointer and Ref. + // as in 'int *& a'. + log_rule("sp_between_ptr_ref"); // ptr_ref 1 + return(options::sp_between_ptr_ref()); + } + else if (second->Is(CT_FUNC_VAR)) + { + // Add or remove space between the pointer star '*' and the name of the + // variable in a function pointer definition. + log_rule("sp_ptr_star_func_var"); + return(options::sp_ptr_star_func_var()); + } + else if (second->Is(CT_FUNC_TYPE)) + { + // Add or remove space between the pointer star '*' and the name of the + // type in a function pointer type definition. + log_rule("sp_ptr_star_func_type"); + return(options::sp_ptr_star_func_type()); + } + else if ( first->GetParentType() == CT_FUNC_DEF + || first->GetParentType() == CT_FUNC_PROTO + || first->GetParentType() == CT_FUNC_VAR) + { + if (token_is_within_trailing_return(first)) + { + // Add or remove space after a pointer star '*', in the trailing return + // a function prototype or function definition. + log_rule("sp_after_ptr_star_trailing"); // ptr_star 3 + return(options::sp_after_ptr_star_trailing()); + } + else + { + // Add or remove space after a pointer star '*', if followed by a function + // prototype or function definition. + log_rule("sp_after_ptr_star_func"); // ptr_star 2 + return(options::sp_after_ptr_star_func()); + } + } + else if (CharTable::IsKw1(second->GetStr()[0])) + { + Chunk *prev = first->GetPrev(); + + if (prev->Is(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()); + } + else if ( first->GetParentType() == CT_FUNC_VAR + || first->GetParentType() == CT_FUNC_TYPE) + { + // 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()); + } + else if (second->Is(CT_QUALIFIER)) + { + // Add or remove space after pointer star '*', if followed by a qualifier. + log_rule("sp_after_ptr_star_qualifier"); // ptr_star 4 + return(options::sp_after_ptr_star_qualifier()); + } + // Add or remove space after pointer star '*', if followed by a word. + log_rule("sp_after_ptr_star"); // ptr_star 1 + return(options::sp_after_ptr_star()); + } + else if (second->Is(CT_PAREN_OPEN)) + { + // Add or remove space after pointer star '*', if followed by a word. + log_rule("sp_after_ptr_star"); // ptr_star 1 + return(options::sp_after_ptr_star()); + } + + // must be placed at the end of the block + // look back for '->' type is TRAILING_RET + if (token_is_within_trailing_return(first)) + { + log_rule("sp_after_ptr_star_trailing"); // ptr_star 3 + return(options::sp_after_ptr_star_trailing()); + } + } + + if ( second->Is(CT_PTR_TYPE) + && first->IsNot(CT_IN)) + { + // look back for '->' type is TRAILING_RET + if (token_is_within_trailing_return(second)) + { + if (first->Is(CT_QUALIFIER)) + { + log_rule("sp_qualifier_ptr_star_trailing"); + return(options::sp_qualifier_ptr_star_trailing()); + } + else + { + log_rule("sp_before_ptr_star_trailing"); // ptr_star 7 + return(options::sp_before_ptr_star_trailing()); + } + } + // Find the next non-'*' chunk + Chunk *next = second; + + do + { + next = next->GetNext(); + } while (next->Is(CT_PTR_TYPE)); + + if ( next->Is(CT_FUNC_DEF) + || next->Is(CT_FUNC_PROTO)) + { + // Add or remove space before a pointer star '*', if followed by a function + // prototype or function definition. If set to ignore, sp_before_ptr_star is + // used instead. + + if (first->Is(CT_QUALIFIER)) + { + if (options::sp_qualifier_ptr_star_func() != IARF_IGNORE) + { + log_rule("sp_qualifier_ptr_star_func"); + return(options::sp_qualifier_ptr_star_func()); + } + } + else + { + if (options::sp_before_ptr_star_func() != IARF_IGNORE) + { + log_rule("sp_before_ptr_star_func"); // ptr_star 6 + return(options::sp_before_ptr_star_func()); + } + } + } + else + { + // 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. + + next = second->GetNextNc(); + + while (next->Is(CT_PTR_TYPE)) + { + next = next->GetNextNc(); + } + + if ( next->IsNotNullChunk() + && next->IsNot(CT_WORD)) + { + if (first->Is(CT_QUALIFIER)) + { + if (options::sp_qualifier_unnamed_ptr_star() != IARF_IGNORE) + { + log_rule("sp_qualifier_unnamed_ptr_star"); + return(options::sp_qualifier_unnamed_ptr_star()); + } + } + else + { + if (next->Is(CT_QUALIFIER)) + { + if (options::sp_before_qualifier_ptr_star() != IARF_IGNORE) + { + log_rule("sp_before_qualifier_ptr_star"); // ptr_star 11 + return(options::sp_before_qualifier_ptr_star()); + } + } + else if (next->Is(CT_OPERATOR)) + { + if (options::sp_before_operator_ptr_star() != IARF_IGNORE) + { + log_rule("sp_before_operator_ptr_star"); // ptr_star 14 + return(options::sp_before_operator_ptr_star()); + } + } + else if (next->Is(CT_DC_MEMBER)) + { + if (options::sp_before_global_scope_ptr_star() != IARF_IGNORE) + { + log_rule("sp_before_global_scope_ptr_star"); // ptr_star 13 + return(options::sp_before_global_scope_ptr_star()); + } + } + else + { + Chunk *next_next = next->GetNextNc(); + + if (next_next->IsNotNullChunk() && next_next->Is(CT_DC_MEMBER)) + { + if (options::sp_before_scope_ptr_star() != IARF_IGNORE) + { + log_rule("sp_before_scope_ptr_star"); // ptr_star 12 + return(options::sp_before_scope_ptr_star()); + } + } + } + + if (options::sp_before_unnamed_ptr_star() != IARF_IGNORE) + { + log_rule("sp_before_unnamed_ptr_star"); // ptr_star 8 + 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"); // ptr_star 5 + return(options::sp_before_ptr_star()); + } + } + + if (first->Is(CT_OPERATOR)) + { + // Add or remove space between 'operator' and operator sign. + log_rule("sp_after_operator"); + return(options::sp_after_operator()); + } + + if ( second->Is(CT_FUNC_PROTO) + || second->Is(CT_FUNC_DEF)) + { + if ( first->IsNot(CT_PTR_TYPE) + && first->IsNot(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 ( ( first->GetParentType() == CT_C_CAST + || first->GetParentType() == CT_D_CAST) + && first->Is(CT_PAREN_CLOSE)) + { + log_rule("sp_after_cast"); + return(options::sp_after_cast()); + } + + if (first->Is(CT_BRACE_CLOSE)) + { + if (second->Is(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) + && second->Is(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 (second->Is(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 (second->Is(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 (first->Is(CT_BRACE_OPEN)) + { + if (first->GetParentType() == CT_ENUM) + { + // Add or remove space inside enum '{' and '}'. + log_rule("sp_inside_braces_enum"); + return(options::sp_inside_braces_enum()); + } + + if ( first->GetParentType() == CT_STRUCT + || first->GetParentType() == CT_UNION) + { + // Fix for issue #1240 adding space in struct initializers + Chunk *tmp = first->GetPrevNcNnl(); + + if (tmp->Is(CT_ASSIGN)) + { + // TODO: provide some test data to check this block + log_rule("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 ( first->GetParentType() == 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 (first->GetParentType() == 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 + && second->Is(CT_BRACE_OPEN) + && second->GetParentType() == 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 + // if statement is a brace_init_lst + // works only if sp_brace_brace is set to ignore. + 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 + // if statement is a brace_init_lst + // works only if sp_brace_brace is set to ignore + // works only if sp_after_type_brace_init_lst_close is set to ignore. + log_rule("sp_inside_type_brace_init_lst"); + return(options::sp_inside_type_brace_init_lst()); + } + } + + if (!second->IsComment()) + { + // Add or remove space inside '{' and '}'. + log_rule("sp_inside_braces"); + return(options::sp_inside_braces()); + } + } + + if ( first->Is(CT_BRACE_CLOSE) + && first->TestFlags(PCF_IN_TYPEDEF) + && ( first->GetParentType() == CT_ENUM + || first->GetParentType() == CT_STRUCT + || first->GetParentType() == 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 ( language_is_set(LANG_D) + && second->Is(CT_PAREN_OPEN) + && second->GetParentType() == 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 ( first->Is(CT_PAREN_CLOSE) + && first->GetParentType() == CT_DECLTYPE + && ( second->Is(CT_WORD) + || second->Is(CT_BRACE_OPEN) + || second->Is(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) + && first->Is(CT_PAREN_CLOSE) + && second->Is(CT_WORD)) + { + // Add or remove space between type and word. + log_rule("sp_after_type"); + return(options::sp_after_type()); + } + + // see if the D template expression is used as a type + if ( language_is_set(LANG_D) + && first->Is(CT_PAREN_CLOSE) + && first->GetParentType() == CT_D_TEMPLATE) + { + if (second->GetParentType() == CT_USING_ALIAS) + { + log_rule("sp_after_type | ADD"); + return(options::sp_after_type() | IARF_ADD); + } + + if (second->Is(CT_WORD)) + { + Chunk *open_paren = first->GetOpeningParen(); + Chunk *type = open_paren->GetPrev()->GetPrev(); + + if (type->Is(CT_TYPE)) + { + log_rule("sp_after_type"); + return(options::sp_after_type()); + } + } + } + + if ( first->Is(CT_TYPE) // Issue #3457 + && second->Is(CT_COLON)) + { + log_rule("sp_type_colon"); + return(options::sp_type_colon()); + } + + if ( !second->Is(CT_PTR_TYPE) + && ( first->Is(CT_QUALIFIER) + || first->Is(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 ( first->Is(CT_PTR_TYPE) + && second->Is(CT_ELLIPSIS)) + { + log_rule("sp_ptr_type_ellipsis"); + return(options::sp_ptr_type_ellipsis()); + } + + // If nothing claimed the PTR_TYPE, then return ignore + if ( first->Is(CT_PTR_TYPE) + || second->Is(CT_PTR_TYPE)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + + if (first->Is(CT_NOT)) + { + if ( second->Is(CT_NOT) + && (options::sp_not_not() != IARF_IGNORE)) + { + log_rule("sp_not_not"); + return(options::sp_not_not()); + } + // Add or remove space after the '!' (not) unary operator. + log_rule("sp_not"); + return(options::sp_not()); + } + + if (first->Is(CT_INV)) + { + // Add or remove space after the '~' (invert) unary operator. + log_rule("sp_inv"); + return(options::sp_inv()); + } + + if (first->Is(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 (first->Is(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 ( first->Is(CT_POS) + || first->Is(CT_NEG)) + { + // Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'. + log_rule("sp_sign"); + return(options::sp_sign()); + } + + if ( first->Is(CT_INCDEC_BEFORE) + || second->Is(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 (second->Is(CT_CS_SQ_COLON)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + if (first->Is(CT_CS_SQ_COLON)) + { + log_rule("FORCE"); + return(IARF_FORCE); + } + + if ( language_is_set(LANG_OC) + && first->Is(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 ( language_is_set(LANG_OC) + && first->Is(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 ( language_is_set(LANG_OC) + && second->Is(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 ( language_is_set(LANG_OC) + && first->Is(CT_OC_COLON)) + { + if (first->TestFlags(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 ( language_is_set(LANG_OC) + && second->Is(CT_OC_COLON)) + { + if ( first->TestFlags(PCF_IN_OC_MSG) + && ( first->Is(CT_OC_MSG_FUNC) + || first->Is(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 ( second->Is(CT_COMMENT) + && second->GetParentType() == CT_COMMENT_EMBED) + { + // Add or remove space before an embedded comment. + // Number of spaces before an embedded comment. + log_rule("sp_before_emb_cmt"); + min_sp = options::sp_num_before_emb_cmt(); + return(options::sp_before_emb_cmt()); + } + + if (first->Is(CT_COMMENT)) + { + // Add or remove space after an embedded comment. + // Number of spaces after an embedded comment. + log_rule("sp_after_emb_cmt"); + min_sp = options::sp_num_after_emb_cmt(); + return(options::sp_after_emb_cmt()); + } + + if ( first->Is(CT_NEW) + && second->Is(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 ( first->Is(CT_NEW) + || first->Is(CT_DELETE) + || ( first->Is(CT_TSQUARE) + && first->GetParentType() == CT_DELETE)) + { + // Add or remove space after 'new', 'delete' and 'delete[]'. + log_rule("sp_after_new"); + return(options::sp_after_new()); + } + + if ( language_is_set(LANG_JAVA) + && first->Is(CT_ANNOTATION) + && second->IsParenOpen()) + { + // (Java) Add or remove space between an annotation and the open parenthesis. + log_rule("sp_annotation_paren"); + return(options::sp_annotation_paren()); + } + + if ( language_is_set(LANG_OC) + && first->Is(CT_OC_PROPERTY)) + { + // (OC) Add or remove space after '@property'. + log_rule("sp_after_oc_property"); + return(options::sp_after_oc_property()); + } + + if ( language_is_set(LANG_D) + && first->Is(CT_EXTERN) + && second->Is(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 ( second->Is(CT_TYPE) + && ( ( first->Is(CT_STRING) + && first->GetParentType() == CT_EXTERN) + || ( first->Is(CT_FPAREN_CLOSE) + && first->GetParentType() == CT_ATTRIBUTE))) + { + log_rule("FORCE"); + return(IARF_FORCE); /* TODO: make this configurable? */ + } + + if (first->Is(CT_NOEXCEPT)) + { + // Add or remove space after 'noexcept'. + log_rule("sp_after_noexcept"); + return(options::sp_after_noexcept()); + } + + // Issue #2138 + if (first->Is(CT_FPAREN_CLOSE)) + { + if (second->Is(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 (second->Is(CT_NOEXCEPT)) + { + // Add or remove space between ')' and 'noexcept'. + log_rule("sp_paren_noexcept"); + return(options::sp_paren_noexcept()); + } + } + + // Issue #2098 + if ( first->Is(CT_PP_PRAGMA) + && second->Is(CT_PREPROC_BODY)) + { + log_rule("REMOVE"); + return(IARF_REMOVE); + } + + // Issue #1733 + if ( first->Is(CT_OPERATOR_VAL) + && second->Is(CT_TYPE)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + + // Issue #995 + if ( first->Is(CT_DO) + && second->Is(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 ( first->Is(CT_BRACE_CLOSE) + && second->Is(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 ( first->Is(CT_NEWLINE) + && second->Is(CT_BRACE_OPEN)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + + // ============================================================= + // category 0 + // this table lists out all combos where nothing is to do + // CT_UNKNOWN is a wildcard. + for (auto it : IGNORE_space_table) + { + if ( ( it.first == CT_UNKNOWN + || it.first == first->GetType()) + && ( it.second == CT_UNKNOWN + || it.second == second->GetType())) + { + log_rule("IGNORE from IGNORE_space_table"); + return(IARF_IGNORE); + } + } + + // ============================================================= + // category 1 + // this table lists out all combos where a space should NOT be present + // CT_UNKNOWN is a wildcard. + size_t number = 0; + + for (auto it : no_space_table) + { + if ( ( it.first == CT_UNKNOWN + || it.first == first->GetType()) + && ( it.second == CT_UNKNOWN + || it.second == second->GetType())) + { + char text[80]; + sprintf(text, "REMOVE from no_space_table @ %zu.", number); + log_rule(text); + return(IARF_REMOVE); + } + number++; + } + + // ============================================================= + // category 2 + // this table lists out all combos where a space MUST be present + number = 0; + + for (auto it : add_space_table) + { + if ( it.first == first->GetType() + && it.second == second->GetType()) + { + char text[80]; + sprintf(text, "ADD from add_space_table @ %zu.", number); + log_rule(text); + return(IARF_ADD); + } + number++; + } + + // Issue #2386 + if ( first->Is(CT_FORM_FEED) + || second->Is(CT_FORM_FEED)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + + // TODO: if necessary create a new option + if ( first->Is(CT_MACRO_FUNC_CALL) + && second->Is(CT_FPAREN_OPEN)) + { + log_rule("IGNORE"); + return(IARF_IGNORE); + } + //// TODO: if necessary create a new option + //if ( first->Is(CT_RPAREN_OPEN) + // && second->Is(CT_RPAREN_CLOSE)) + //{ + // log_rule("IGNORE"); + // return(IARF_IGNORE); + //} + + //// TODO: if necessary create a new option + //if ( first->Is(CT_RPAREN_OPEN) + // && second->Is(CT_UNKNOWN)) + //{ + // log_rule("IGNORE"); + // return(IARF_IGNORE); + //} + + //// TODO: if necessary create a new option + //if ( first->Is(CT_UNKNOWN) + // && second->Is(CT_RPAREN_CLOSE)) + //{ + // log_rule("IGNORE"); + // return(IARF_IGNORE); + //} + + if ( first->Is(CT_CASE_ELLIPSIS) + && second->Is(CT_NUMBER)) + { + // Add or remove space after the variadic '...' when preceded by a + // non-punctuator. + // The value REMOVE will be overridden with FORCE + if (options::sp_after_ellipsis() == IARF_REMOVE) + { + log_rule("sp_after_ellipsis/FORCE"); + return(IARF_FORCE); + } + else + { + log_rule("sp_after_ellipsis"); + return(options::sp_after_ellipsis()); + } + } + + if ( first->Is(CT_NUMBER) + && second->Is(CT_CASE_ELLIPSIS)) + { + // Add or remove space before the variadic '...' when preceded by a + // non-punctuator. + // The value REMOVE will be overridden with FORCE + if (options::sp_before_ellipsis() == IARF_REMOVE) + { + log_rule("sp_before_ellipsis/FORCE"); + return(IARF_FORCE); + } + else + { + log_rule("sp_before_ellipsis"); + return(options::sp_before_ellipsis()); + } + } + // ============================================================= + // category 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, orig col is %zu, Text() '%s', GetType() is %s\n", + first->GetOrigLine(), first->GetOrigCol(), first->Text(), get_token_name(first->GetType())); + LOG_FMT(LSPACE, " second orig line is %zu, orig col is %zu, Text() '%s', GetType() is %s\n", + second->GetOrigLine(), second->GetOrigCol(), second->Text(), get_token_name(second->GetType())); + 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, " { CT_%s, CT_%s},\n", + get_token_name(first->GetType()), get_token_name(second->GetType())); + LOG_FMT(LSPACE, " in the file <Path_to_uncrustify>/src/add_space_table.h\n"); + + log_rule("ADD as default value"); + return(IARF_ADD); +} // do_space + + +static iarf_e ensure_force_space(Chunk *first, Chunk *second, iarf_e av) +{ + if (first->TestFlags(PCF_FORCE_SPACE)) + { + LOG_FMT(LSPACE, "%s(%d): force between '%s' and '%s'\n", + __func__, __LINE__, first->Text(), second->Text()); + return(av | IARF_ADD); + } + return(av); +} + + +static iarf_e do_space_ensured(Chunk *first, Chunk *second, int &min_sp) +{ + return(ensure_force_space(first, second, do_space(first, second, min_sp))); +} + + +void space_text() +{ + LOG_FUNC_ENTRY(); + + Chunk *pc = Chunk::GetHead(); + Chunk *next; + size_t prev_column; + size_t column = pc->GetColumn(); + + while (pc->IsNotNullChunk()) + { + if (pc->Is(CT_NEWLINE)) + { + LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, <Newline>, nl is %zu\n", + __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->GetNlCount()); + } + 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->GetOrigLine(), pc->GetOrigCol(), pc->ElidedText(copy), get_token_name(pc->GetType())); + } + + 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->GetOrigLine(), get_token_name(pc->GetType())); + pc->SetFlagBits(PCF_IN_QT_MACRO); // flag the chunk for a second processing + + // save the values + save_set_options_for_QT(pc->GetLevel()); + } + + // Bug # 637 + // If true, vbrace tokens are dropped to the previous token and skipped. + if (options::sp_skip_vbrace_tokens()) + { + next = pc->GetNext(); + + while ( next->IsEmptyText() + && !next->IsNewline() + && next->IsVBrace()) + { + LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, Skip %s (%zu+%zu)\n", + __func__, __LINE__, next->GetOrigLine(), next->GetOrigCol(), get_token_name(next->GetType()), + pc->GetColumn(), pc->GetStr().size()); + next->SetColumn(pc->GetColumn() + pc->GetStr().size()); + next = next->GetNext(); + } + } + else + { + next = pc->GetNext(); + } + + if (next->IsNullChunk()) + { + break; + } + + // Issue # 481 + // Whether to balance spaces inside nested parentheses. + if ( QT_SIGNAL_SLOT_found + && options::sp_balance_nested_parens()) + { + Chunk *nn = next->GetNext(); // Issue #2734 + + if ( nn->IsNotNullChunk() + && nn->Is(CT_SPACE)) + { + Chunk::Delete(nn); // remove the space + } + } + + /* + * If the current chunk contains a newline, do not change the column + * of the next item + */ + if ( pc->IsNewline() + || pc->Is(CT_COMMENT_MULTI)) + { + column = next->GetColumn(); + } + else + { + // Set to the minimum allowed column + if (pc->GetNlCount() == 0) + { + column += pc->Len(); + } + else + { + column = pc->GetOrigColEnd(); + } + 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. + */ + pc->ResetFlagBits(PCF_FORCE_SPACE); + + if ( (pc->Len() > 0) + && !pc->IsString("[]") + && !pc->IsString("{{") + && !pc->IsString("}}") + && !pc->IsString("()") + && !pc->GetStr().startswith("@\"")) + { + // Find the next non-empty chunk on this line + Chunk *tmp = next; + + while ( tmp->IsNotNullChunk() + && (tmp->Len() == 0) + && !tmp->IsNewline()) + { + tmp = tmp->GetNext(); + } + + if ( tmp->IsNotNullChunk() + && tmp->Len() > 0) + { + bool kw1 = CharTable::IsKw2(pc->GetStr()[pc->Len() - 1]); + bool kw2 = CharTable::IsKw1(next->GetStr()[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()); + pc->SetFlagBits(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))) + && pc->Is(CT_ANGLE_CLOSE) + && next->Is(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()); + pc->SetFlagBits(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->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); + 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; + + // Handle the condition of a CT_VBRACE_OPEN with more complicated spacing mechanics. + if ( pc->Is(CT_VBRACE_OPEN) + && next->GetOrigCol() >= pc->GetPrev()->GetOrigCol()) + { + delta = next->GetOrigCol() - pc->GetPrev()->GetOrigCol(); + + if ((delta - 1) < min_sp) + { + column += min_sp; + break; + } + column += (delta - 1); + break; + } + + if ( next->GetOrigCol() >= pc->GetOrigColEnd() + && pc->GetOrigColEnd() != 0) + { + // Keep the same relative spacing, minimum 1 + delta = next->GetOrigCol() - pc->GetOrigColEnd(); + + 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->GetOrigCol() >= pc->GetOrigColEnd() + && pc->GetOrigColEnd() != 0) + { + column += next->GetOrigCol() - pc->GetOrigColEnd(); + } + else + { + // preserve the position if virtual brace + // Issue #1854 + if (pc->Is(CT_VBRACE_OPEN)) + { + column = next->GetOrigCol(); + } + } + break; + + default: + // If we got here, something is wrong... + break; + } // switch + + if ( next->IsComment() + && next->GetNext()->IsNewline() + && column < next->GetOrigCol()) + { + /* + * do some comment adjustments if sp_before_tr_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_cmt() == IARF_IGNORE + || next->GetParentType() != CT_COMMENT_END) + && ( options::sp_endif_cmt() == IARF_IGNORE + || ( pc->IsNot(CT_PP_ELSE) + && pc->IsNot(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', orig col is %zu, next orig col is %zu, pc orig col end is %zu\n", + __func__, __LINE__, pc->Text(), + pc->GetOrigCol(), next->GetOrigCol(), pc->GetOrigColEnd()); + column = pc->GetColumn() + (next->GetOrigCol() - pc->GetOrigColEnd()); + } + 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->GetColumn() + pc->Len() + ((next->GetOrigPrevSp() > 0) ? 1 : 0); + column = next->GetOrigCol(); + + if (column < col_min) + { + column = col_min; + } + LOG_FMT(LSPACE, "%s(%d): <relative set>", __func__, __LINE__); + } + } + } + next->SetColumn(column); + LOG_FMT(LSPACE, "%s(%d): orig line is %zu, orig col is %zu, pc-Text() '%s', type is %s\n", + __func__, __LINE__, pc->GetOrigLine(), pc->GetOrigCol(), pc->Text(), get_token_name(pc->GetType())); + LOG_FMT(LSPACE, "%s(%d): ", + __func__, __LINE__); + 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->GetColumn()); + + if (restoreValues) // guy 2015-09-22 + { + restore_options_for_QT(); + } + } + pc = next; + + if (QT_SIGNAL_SLOT_found) + { + // flag the chunk for a second processing + pc->SetFlagBits(PCF_IN_QT_MACRO); + } + } +} // space_text + + +void space_text_balance_nested_parens() +{ + LOG_FUNC_ENTRY(); + + Chunk *first = Chunk::GetHead(); + + while (first->IsNotNullChunk()) + { + Chunk *next = first->GetNext(); + + if (next->IsNullChunk()) + { + break; + } + + // if there are two successive opening parenthesis + if ( first->IsString("(") + && next->IsString("(")) + { + // insert a space between them + space_add_after(first, 1); + + // test after the closing parens Issue #1703 + Chunk *closing = first->GetNextType((E_Token)(first->GetType() + 1), first->GetLevel()); + + if (closing->GetOrigCol() == closing->GetPrev()->GetOrigColEnd()) + { + space_add_after(closing->GetPrev(), 1); + } + } + else if ( first->IsString(")") + && next->IsString(")")) + { + // insert a space between the two closing parens + space_add_after(first, 1); + + // test after the opening parens Issue #1703 + Chunk *opening = next->GetPrevType((E_Token)(next->GetType() - 1), next->GetLevel()); + + if (opening->GetOrigColEnd() == opening->GetNext()->GetOrigCol()) + { + space_add_after(opening, 1); + } + } + first = next; + } +} // space_text_balance_nested_parens + + +size_t space_needed(Chunk *first, Chunk *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->GetOrigCol() > (first->GetOrigCol() + first->Len())); + } +} + + +size_t space_col_align(Chunk *first, Chunk *second) +{ + LOG_FUNC_ENTRY(); + + LOG_FMT(LSPACE, "%s(%d): 1st orig line %zu, orig col %zu, [%s/%s], text '%s' <==>\n", + __func__, __LINE__, first->GetOrigLine(), first->GetOrigCol(), + get_token_name(first->GetType()), get_token_name(first->GetParentType()), + first->Text()); + LOG_FMT(LSPACE, "%s(%d): 2nd orig line %zu, orig col %zu, [%s/%s], text '%s'\n", + __func__, __LINE__, second->GetOrigLine(), second->GetOrigCol(), + get_token_name(second->GetType()), get_token_name(second->GetParentType()), + 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->GetNlCount() > 0) + { + LOG_FMT(LSPACE, "%s(%d): new line count %zu, orig col end %zu\n", + __func__, __LINE__, first->GetNlCount(), first->GetOrigColEnd()); + coldiff = first->GetOrigColEnd() - 1; + } + else + { + LOG_FMT(LSPACE, "%s(%d): '1st' 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->GetOrigLine()); + LOG_FMT(LSPACE, "%s(%d): => second orig line is %zu\n", __func__, __LINE__, second->GetOrigLine()); + 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->GetOrigCol()); + LOG_FMT(LSPACE, "%s(%d): => second orig col is %zu\n", __func__, __LINE__, second->GetOrigCol()); + LOG_FMT(LSPACE, "%s(%d): => first len is %zu\n", __func__, __LINE__, first->Len()); + + if ( first->GetOrigLine() == second->GetOrigLine() + && second->GetOrigCol() > (first->GetOrigCol() + 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 *pc, size_t count) +{ + LOG_FUNC_ENTRY(); + + Chunk *next = pc->GetNext(); + + // don't add at the end of the file or before a newline + if ( next->IsNullChunk() + || next->IsNewline()) + { + return; + } + + // Limit to 16 spaces + if (count > 16) + { + count = 16; + } + + // Two CT_SPACE in a row -- use the max of the two + if (next->Is(CT_SPACE)) + { + if (next->Len() < count) + { + while (next->Len() < count) + { + next->Str().append(' '); + } + } + return; + } + Chunk sp; + + sp.SetType(CT_SPACE); + sp.SetFlags(pc->GetFlags() & PCF_COPY_FLAGS); + sp.Str() = " "; // 16 spaces + sp.Str().resize(count); + sp.SetLevel(pc->GetLevel()); + sp.SetBraceLevel(pc->GetBraceLevel()); + sp.SetPpLevel(pc->GetPpLevel()); + sp.SetColumn(pc->GetColumn() + pc->Len()); + sp.SetOrigLine(pc->GetOrigLine()); + sp.SetOrigCol(pc->GetOrigCol()); + + sp.CopyAndAddAfter(pc); +} // space_add_after |