{

LOG_FUNC_ENTRY();

LOG_FMT(LSPACE, "%s(%d): first: orig line %zu, orig col %zu, text '%s', type %s\n",

__func__, __LINE__, first->GetOrigLine(), first->GetOrigCol(), first->GetLogText(), get_token_name(first->GetType()));

LOG_FMT(LSPACE, "%s(%d): second: orig line %zu, orig col %zu, text '%s', type %s\n",

__func__, __LINE__, second->GetOrigLine(), second->GetOrigCol(), second->GetLogText(), get_token_name(second->GetType()));

min_sp = 1;

// test if we are within a macro-no-format-args call

// Tokens inside these macros were marked with PCF_IN_MACRO_NO_FMT_ARGS

// during tokenize_cleanup(), so we just need to check the flag

// This check must be early to prevent other rules from modifying spacing

if ( first->TestFlags(PCF_IN_MACRO_NO_FMT_ARGS)

|| second->TestFlags(PCF_IN_MACRO_NO_FMT_ARGS))

{

log_rule("IGNORE (inside macro-no-format-args)");

return(IARF_IGNORE);

}

if ( first->Is(E_Token::CT_COMMENT) // Issue #4327

&& first->GetParentType() == E_Token::CT_COMMENT_EMBED

&& (options::sp_emb_cmt_priority()))

{

// Add or remove space between an embedded comment and a close parenthesis.

log_rule("sp_emb_cmt_priority (after)");

min_sp = options::sp_num_after_emb_cmt();

return(options::sp_after_emb_cmt());

}

if ( second->Is(E_Token::CT_COMMENT) // Issue #4327

&& second->GetParentType() == E_Token::CT_COMMENT_EMBED

&& (options::sp_emb_cmt_priority()))

{

// Add or remove space between an open parenthesis and an embedded comment.

log_rule("sp_between_open_paren_and_emb_cmt (before)");

min_sp = options::sp_num_before_emb_cmt();

return(options::sp_before_emb_cmt());

}

if ( first->Is(E_Token::CT_VBRACE_OPEN)

&& first->GetPrev()->Is(E_Token::CT_SPAREN_CLOSE)

&& second->IsNot(E_Token::CT_SEMICOLON))

{

// Add or remove space after ')' of control statements.

log_rule("sp_after_sparen");

return(options::sp_after_sparen());

}

if (first->Is(E_Token::CT_SPAREN_CLOSE))

{

if (second->Is(E_Token::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(E_Token::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(E_Token::CT_PP_IGNORE)

&& second->Is(E_Token::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(E_Token::CT_PP)

|| second->Is(E_Token::CT_PP))

{

// Add or remove space around preprocessor '##' concatenation operator.

log_rule("sp_pp_concat");

return(options::sp_pp_concat());

}

if (first->Is(E_Token::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(E_Token::CT_POUND)

&& second->TestFlags(PCF_IN_PREPROC)

&& first->GetParentType() != E_Token::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(E_Token::CT_DECLSPEC)) // Issue 1289

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if ( second->Is(E_Token::CT_NEWLINE)

|| second->Is(E_Token::CT_VBRACE_OPEN))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if ( first->Is(E_Token::CT_VBRACE_OPEN)

&& second->IsNot(E_Token::CT_NL_CONT)

&& second->IsNot(E_Token::CT_SEMICOLON)) // # Issue 1158

{

log_rule("FORCE");

return(IARF_FORCE);

}

if ( first->Is(E_Token::CT_VBRACE_CLOSE)

&& second->IsNot(E_Token::CT_NL_CONT))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if (second->Is(E_Token::CT_VSEMICOLON))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if (first->Is(E_Token::CT_MACRO_FUNC))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if (second->Is(E_Token::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_flag_e::LANG_D)

&& ( first->Is(E_Token::CT_D_ARRAY_COLON)

|| second->Is(E_Token::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(E_Token::CT_CASE)

&& (( CharTable::IsKw1(second->GetText()[0])

|| second->Is(E_Token::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(E_Token::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(E_Token::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(E_Token::CT_QUESTION)

&& second->Is(E_Token::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(E_Token::CT_QUESTION) // see the tests cpp:34513-34516

|| second->Is(E_Token::CT_QUESTION))

{

if ( second->Is(E_Token::CT_QUESTION)

&& (options::sp_cond_question_before() != IARF_IGNORE))

{

if (second->TestFlags(PCF_IN_TEMPLATE))

{

// do nothing

}

else

{

// 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(E_Token::CT_QUESTION)

&& (options::sp_cond_question_after() != IARF_IGNORE))

{

if (first->TestFlags(PCF_IN_TEMPLATE))

{

// do nothing

}

else

{

// 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());

}

}

if ( first->TestFlags(PCF_IN_TEMPLATE)

|| second->TestFlags(PCF_IN_TEMPLATE))

{

// do nothing

}

else

{

log_rule("sp_cond_question");

return(options::sp_cond_question());

}

}

if ( first->Is(E_Token::CT_COND_COLON)

|| second->Is(E_Token::CT_COND_COLON))

{

if ( second->Is(E_Token::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(E_Token::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(E_Token::CT_WORD) && second->Is(E_Token::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_flag_e::LANG_D)

&& ( first->Is(E_Token::CT_RANGE)

|| second->Is(E_Token::CT_RANGE)))

{

// (D) Add or remove space around the D '..' operator.

log_rule("sp_range");

return(options::sp_range());

}

if ( first->Is(E_Token::CT_COLON)

&& first->GetParentType() == E_Token::CT_SQL_EXEC)

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

// Macro stuff can only return IGNORE, ADD, or FORCE

if (first->Is(E_Token::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(E_Token::CT_FPAREN_CLOSE)

&& first->GetParentType() == E_Token::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(E_Token::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(E_Token::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(E_Token::CT_SEMICOLON)) // see the tests cpp:34517-34519

{

if ( first->Is(E_Token::CT_VBRACE_OPEN) // Issue #2942

&& first->GetPrev()->Is(E_Token::CT_SPAREN_CLOSE))

{

if ( first->GetParentType() == E_Token::CT_IF

|| first->GetParentType() == E_Token::CT_FOR

|| first->GetParentType() == E_Token::CT_WHILE)

{

// Add or remove space before empty statement ';' on 'if', 'for' and 'while'.

log_rule("sp_special_semi");

return(options::sp_special_semi());

}

}

// Issue #4094-03

if (second->GetParentType() == E_Token::CT_FOR)

{

if (first->Is(E_Token::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(E_Token::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());

}

else

{

// Add or remove space before ';'.

log_rule("sp_before_semi");

return(options::sp_before_semi());

}

}

if ( ( second->Is(E_Token::CT_COMMENT)

|| second->Is(E_Token::CT_COMMENT_CPP))

&& ( first->Is(E_Token::CT_PP_ELSE)

|| first->Is(E_Token::CT_PP_ENDIF)))

{

if (second->Is(E_Token::CT_COMMENT_CPP))

{

second->SetType(E_Token::CT_COMMENT_CPP_ENDIF);

}

else

{

second->SetType(E_Token::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() == E_Token::CT_COMMENT_END)

{

// Add or remove space before a trailing comment.

// Number of spaces before a trailing comment.

log_rule("sp_before_tr_cmt");

log_rule("sp_num_before_tr_cmt");

min_sp = options::sp_num_before_tr_cmt();

return(options::sp_before_tr_cmt());

}

if (second->GetParentType() == E_Token::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(E_Token::CT_SEMICOLON)) // see the tests cpp:34517-34519

{

if (first->GetParentType() == E_Token::CT_FOR)

{

if (second->Is(E_Token::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(E_Token::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(E_Token::CT_BRACE_CLOSE)) // issue #197

{

// Add or remove space after ';', except when followed by a comment.

// see the tests cpp:34517-34519

// issue #4590: Don't add space when ';' is inside a one-liner body

// and is followed by virtual closing braces that lead directly into

// a real closing brace. Virtual braces have zero length, so the

// space would incorrectly appear before the real '}'.

bool use_sp_after_semi = true;

if ( second->Is(E_Token::CT_VBRACE_CLOSE)

&& first->TestFlags(PCF_ONE_LINER))

{

Chunk const *tmp = second;

while (tmp->Is(E_Token::CT_VBRACE_CLOSE))

{

tmp = tmp->GetNext();

}

if (tmp->Is(E_Token::CT_BRACE_CLOSE))

{

use_sp_after_semi = false;

}

}

if (use_sp_after_semi)

{

log_rule("sp_after_semi");

return(options::sp_after_semi());

}

else

{

log_rule("sp_inside_braces");

return(options::sp_inside_braces());

}

}

// Let the comment spacing rules handle this

}

// puts a space in the rare '+-' or '-+'

if ( ( first->Is(E_Token::CT_NEG)

|| first->Is(E_Token::CT_POS)

|| first->Is(E_Token::CT_ARITH)

|| first->Is(E_Token::CT_SHIFT))

&& ( second->Is(E_Token::CT_NEG)

|| second->Is(E_Token::CT_POS)

|| second->Is(E_Token::CT_ARITH)

|| second->Is(E_Token::CT_SHIFT)))

{

log_rule("ADD");

return(IARF_ADD);

}

// "return(a);" vs. "return (foo_t)a + 3;" vs. "return a;" vs. "return;"

// co_return, co_yield and co_await take the same spacing options.

// sp_return_brace only ever applies to the first two: co_return and

// co_yield accept a braced-init-list, co_await does not

if ( first->Is(E_Token::CT_RETURN)

|| first->Is(E_Token::CT_CO_RETURN)

|| first->Is(E_Token::CT_CO_AWAIT)

|| first->Is(E_Token::CT_CO_YIELD))

{

if ( second->Is(E_Token::CT_PAREN_OPEN)

&& ( second->GetParentType() == E_Token::CT_RETURN

|| second->GetParentType() == E_Token::CT_CO_RETURN

|| second->GetParentType() == E_Token::CT_CO_AWAIT

|| second->GetParentType() == E_Token::CT_CO_YIELD))

{

// Add or remove space between 'return' and '('.

log_rule("sp_return_paren");

return(options::sp_return_paren());

}

else if ( second->Is(E_Token::CT_BRACE_OPEN)

&& second->GetParentType() == E_Token::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(E_Token::CT_SIZEOF))

{

if (second->Is(E_Token::CT_PAREN_OPEN))

{

// Add or remove space between 'sizeof' and '('.

log_rule("sp_sizeof_paren");

return(options::sp_sizeof_paren());

}

if (second->Is(E_Token::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);

}

if ( ( first->Is(E_Token::CT_FPAREN_OPEN)

|| first->Is(E_Token::CT_SPAREN_OPEN)

|| first->Is(E_Token::CT_PAREN_OPEN))

&& second->Is(E_Token::CT_DEREF)) // Issue #4459

{

log_rule("sp_paren_deref");

return(options::sp_paren_deref());

}

// "decltype(foo_t)" vs. "decltype (foo_t)"

if (first->Is(E_Token::CT_DECLTYPE))

{

if (second->Is(E_Token::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(E_Token::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(E_Token::CT_PAREN_CLOSE)

&& second->Is(E_Token::CT_DC_MEMBER)

&& second->GetNext()->GetType() == E_Token::CT_FUNC_CALL)

{

log_rule("sp_after_cast");

return(options::sp_after_cast());

}

if (second->Is(E_Token::CT_DC_MEMBER))

{

/* '::' at the start of an identifier is not member access, but global scope operator.

switch (first->GetType())

{

case E_Token::CT_SBOOL:

case E_Token::CT_SASSIGN:

case E_Token::CT_ARITH:

case E_Token::CT_SHIFT:

case E_Token::CT_CASE:

case E_Token::CT_CLASS:

case E_Token::CT_DELETE:

case E_Token::CT_FRIEND:

case E_Token::CT_NAMESPACE:

case E_Token::CT_NEW:

case E_Token::CT_SARITH:

case E_Token::CT_SCOMPARE:

case E_Token::CT_OPERATOR:

case E_Token::CT_ACCESS:

case E_Token::CT_QUALIFIER:

case E_Token::CT_RETURN:

case E_Token::CT_CO_AWAIT:

case E_Token::CT_CO_YIELD:

case E_Token::CT_CO_RETURN:

case E_Token::CT_SIZEOF:

case E_Token::CT_DECLTYPE:

case E_Token::CT_STRUCT:

case E_Token::CT_THROW:

case E_Token::CT_TYPEDEF:

case E_Token::CT_TYPENAME:

case E_Token::CT_UNION:

case E_Token::CT_USING:

log_rule("FORCE");

return(IARF_FORCE);

default:

break;

}

if ( ( first->Is(E_Token::CT_WORD)

|| first->Is(E_Token::CT_TYPE)

|| first->Is(E_Token::CT_PAREN_CLOSE)

|| CharTable::IsKw1(first->GetText()[0]))

&& (strcmp(first->GetLogText(), "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(E_Token::CT_COMMA)) // see the tests cpp:34520-34524

// see the tests c-sharp:12200-12202

{

if ( ( language_is_set(lang_flag_e::LANG_CS)

|| language_is_set(lang_flag_e::LANG_VALA))

&& first->GetParentType() == E_Token::CT_TYPE)

{

// (C#, Vala) multidimensional array type: ',,' vs. ', ,' or ',]' vs. ', ]'

if (second->Is(E_Token::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(E_Token::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(E_Token::CT_FPAREN_CLOSE)

&& ( second->Is(E_Token::CT_FPAREN_CLOSE)

|| second->Is(E_Token::CT_COMMA)))

{

if (second->GetLevel() == QT_SIGNAL_SLOT_level)

{

restoreValues = true;

}

}

}

if (second->Is(E_Token::CT_COMMA))

{

if ( ( language_is_set(lang_flag_e::LANG_CS)

|| language_is_set(lang_flag_e::LANG_VALA))

&& first->Is(E_Token::CT_SQUARE_OPEN)

&& first->GetParentType() == E_Token::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(E_Token::CT_PAREN_OPEN)

|| first->Is(E_Token::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(E_Token::CT_ELLIPSIS))

{

// type followed by a ellipsis

Chunk const *tmp = first;

if ( tmp->Is(E_Token::CT_PTR_TYPE)

|| tmp->Is(E_Token::CT_BYREF))

{

tmp = tmp->GetPrevNcNnl();

}

if ( tmp->Is(E_Token::CT_TYPE)

|| tmp->Is(E_Token::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(E_Token::CT_FPAREN_CLOSE)

|| first->Is(E_Token::CT_PAREN_CLOSE))

{

// Add or remove space between ')' and '...'.

log_rule("sp_paren_ellipsis");

return(options::sp_paren_ellipsis());

}

if (first->Is(E_Token::CT_TAG_COLON))

{

log_rule("FORCE");

return(IARF_FORCE);

}

if (first->Is(E_Token::CT_BYREF)) // Issue #3309

{

log_rule("sp_byref_ellipsis");

return(options::sp_byref_ellipsis());

}

if (first->Is(E_Token::CT_PARAMETER_PACK)) // Issue #3309

{

log_rule("sp_parameter_pack_ellipsis");

return(options::sp_parameter_pack_ellipsis());

}

}

if (first->Is(E_Token::CT_ELLIPSIS))

{

if (second->Is(E_Token::CT_PARAMETER_PACK)) // Issue #3309

{

log_rule("sp_ellipsis_parameter_pack");

return(options::sp_ellipsis_parameter_pack());

}

if (CharTable::IsKw1(second->GetText()[0]))

{

log_rule("FORCE");

return(IARF_FORCE);

}

if ( second->Is(E_Token::CT_PAREN_OPEN)

&& first->GetPrev()->Is(E_Token::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_flag_e::LANG_PAWN)

&& first->Is(E_Token::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(E_Token::CT_TAG_COLON))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

// handle '~'

if (first->Is(E_Token::CT_DESTRUCTOR))

{

log_rule("REMOVE");

return(IARF_REMOVE);

}

if ( language_is_set(lang_flag_e::LANG_OC)

&& first->Is(E_Token::CT_CATCH)

&& second->Is(E_Token::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_flag_e::LANG_OC)

&& ( first->Is(E_Token::CT_PAREN_CLOSE)

|| first->Is(E_Token::CT_OC_CLASS)

|| first->Is(E_Token::CT_WORD))

&& second->Is(E_Token::CT_ANGLE_OPEN)

&& ( second->GetParentType() == E_Token::CT_OC_PROTO_LIST

|| second->GetParentType() == E_Token::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_flag_e::LANG_OC)

&& first->Is(E_Token::CT_OC_CLASS)

&& second->Is(E_Token::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(E_Token::CT_CATCH)

&& second->Is(E_Token::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_flag_e::LANG_D)

&& first->Is(E_Token::CT_D_VERSION_IF)

&& second->Is(E_Token::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_flag_e::LANG_D)

&& first->Is(E_Token::CT_D_SCOPE_IF)

&& second->Is(E_Token::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_flag_e::LANG_OC)

&& first->Is(E_Token::CT_SYNCHRONIZED)

&& second->Is(E_Token::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(E_Token::CT_SPAREN_OPEN))

{

// Add or remove space after 'do' between 'while' and '('. Issue #995

if ( first->Is(E_Token::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(E_Token::CT_LAMBDA)

|| second->Is(E_Token::CT_LAMBDA))

{

// Add or remove space around assignment operator '=', '+=', etc.

log_rule("sp_assign");

return(options::sp_assign());

}

// Handle the special lambda case for C++11: