/*
* Tests for the token lsym_binary_op, which represents a binary operator in
* an expression. Examples for binary operators are '>>', '=', '+', '&&'.
*
* Binary operators are surrounded by blanks.
*
* Some tokens like '+', '*' or '&' can be either binary or unary operators,
* with an entirely different meaning.
*
* The token '*' is not only a binary or a unary operator, it is used in types
* as well, to derive a pointer type.
*
* See also:
* lsym_postfix_op.c for postfix unary operators
* lsym_unary_op.c for prefix unary operators
* lsym_colon.c for ':'
* lsym_question.c for '?'
* lsym_comma.c for ','
* C99 6.4.6 "Punctuators"
*/
//indent input
void
binary_operators(void)
{
/* In the order of appearance in C11 6.5. */
a = a * a;
a = a / a;
a = a % a;
a = a + a;
a = a - a;
a = a << a;
a = a >> a;
a = a < a;
a = a > a;
a = a <= a;
a = a >= a;
a = a == a;
a = a != a;
a = a & a;
a = a ^ a;
a = a | a;
a = a && a;
a = a || a;
a = a ? a : a;
a = a;
a *= a;
a /= a;
a %= a;
a += a;
a -= a;
a <<= a;
a >>= a;
a &= a;
a ^= a;
a |= a;
a = a, a;
}
//indent end
//indent run-equals-input
/*
* If a '*' is immediately followed by another '*', they still form separate
* operators. The first is a binary operator, the second is unary.
*/
//indent input
int var = expr**ptr;
//indent end
//indent run -di0
int var = expr * *ptr;
//indent end
/*
* Before 2023-06-04, indent allowed for arbitrary repetitions of some operator
* characters, followed by an arbitrary amount of '='. This could be used for
* operators like '&&' or '|||==='.
*
* Before 2021-03-07 22:11:01, the comment '//' was treated as a binary
* operator as well, and so was the comment '/////', leading to unexpected
* spacing.
*
* See lexi.c, lexi, "default:".
*/
//indent input
void
long_run_of_operators(void)
{
if (a &&&&&&& b)
return;
if (a |||=== b)
return;
}
//indent end
//indent run
void
long_run_of_operators(void)
{
if (a && && && &b)
return;
if (a || |= == b)
return;
}
//indent end
/*
* Long chains of '+' and '-' must be split into several operators as the
* lexer has to distinguish between '++' and '+' early. The following
* sequence is thus tokenized as:
*
* word "a"
* postfix_op "++"
* binary_op "++"
* unary_op "++"
* unary_op "+"
* word "b"
*
* See lexi.c, lexi, "case '+':".
*/
//indent input
void
joined_unary_and_binary_operators(void)
{
if (a +++++++ b)
return;
}
//indent end
//indent run
void
joined_unary_and_binary_operators(void)
{
if (a++ ++ ++ +b)
return;
}
//indent end
/*
* Ensure that the result of the indentation does not depend on whether a
* token from the input starts in column 1 or 9.
*
* See process_binary_op.
*/
//indent input
int col_1 //
= //
1;
int col_9 //
= //
9;
//indent end
//indent run
int col_1 //
= //
1;
int col_9 //
= //
9;
//indent end
/*
* The ternary conditional operator is not a binary operator, but both its
* components '?' and ':' follow the same spacing rules.
*/
//indent input
int conditional = condition ? number : number;
//indent end
//indent run-equals-input -di0
// After a ']', a '*' is a binary operator.
//indent input
int x = arr[3]*y;
//indent end
//indent run -di0
int x = arr[3] * y;
//indent end
/*
* Ensure that after an assignment, a '*=' operator is properly spaced, like
* any other binary operator.
*/
//indent input
{
a = a;
a *= b *= c;
}
//indent end
