xref: /netbsd-src/tests/usr.bin/indent/lsym_binary_op.c (revision 61c5d6b6d061f79b8dfac16a2fd4b51a7692a89f)

/* $NetBSD: lsym_binary_op.c,v 1.12 2023/06/14 08:25:15 rillig Exp $ */

/*
 * 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

//indent run-equals-input -di0