/*	$NetBSD: c11_generic_expression.c,v 1.27 2026/07/15 05:35:10 rillig Exp $	*/
# 3 "c11_generic_expression.c"

/* lint1-extra-flags: -X 351 */

/*
 * C99 added support for type-generic macros, but these were limited to the
 * header <tgmath.h>.  C11 made this feature generally available.
 *
 * The generic selection is typically used with macros, but since lint1 works
 * on the preprocessed source, the test cases look a bit strange.
 *
 * C11 6.5.1.1 "Generic selection"
 */

/* lint1-extra-flags: -Ac11 */

/*
 * The type of 'var' is not compatible with any of the types from the
 * generic-association.  This is a constraint violation that the compiler must
 * detect, therefore lint doesn't repeat that diagnostic.
 */
const char *
classify_type_without_default(double var)
{
	/* expect-2: warning: parameter 'var' unused in function 'classify_type_without_default' [231] */

	return _Generic(var,
	    long double: "long double",
	    long long: "long long",
	    unsigned: "unsigned"
	);
	/* expect-1: error: function 'classify_type_without_default' expects to return value [214] */
}

/*
 * In this case, the 'default' expression is selected.
 */
const char *
classify_type_with_default(double var)
{
	/* expect-2: warning: parameter 'var' unused in function 'classify_type_with_default' [231] */

	return _Generic(var,
	    long double: "long double",
	    long long: "long long",
	    unsigned: "unsigned",
	    default: "unknown"
	);
}

/*
 * The type of a _Generic expression is the one from the selected association.
 */
const char *
classify_char(char c)
{
	/* expect-2: warning: parameter 'c' unused in function 'classify_char' [231] */

	return _Generic(c,
	    char: "yes",
	    default: 0.0
	);
}

/*
 * Before cgram.y 1.238 from 2021-06-27, lint accepted a comma-expression,
 * which looked as if _Generic would accept multiple arguments before the
 * selection.
 */
/* ARGSUSED */
const int *
comma_expression(char first, double second)
{
	/* expect+1: error: syntax error 'second' [249] */
	return _Generic(first, second,
	    char: "first",
	    double: 2.0
	);
	/* expect+1: warning: function 'comma_expression' falls off bottom without returning value [217] */
}

/*
 * Ensure that assignment-expressions are accepted by the grammar, as
 * opposed to comma-expressions.
 */
/* ARGSUSED */
int
assignment_expression(int first, int second)
{
	return _Generic(first = second,
	    int: second = first
	);
}

int
primary_expression(void)
{
	return _Generic(0, int: assignment_expression)(0, 0);
}

/*
 * The types don't match, therefore the _Generic selection evaluates to NULL,
 * which is then silently ignored by init_expr.  This situation is already
 * covered by the compilers, so there is no need for lint to double-check it.
 */
const char *x = _Generic(
    1ULL + 1.0f,
    int: 1
);

// In C11 6.5.2.1, type qualifiers were not required to be removed.
// C23 6.5.2.1 added that requirement.
void
type_conversions(const char *str)
{
	int array[4] = { 0, 1, 2, 3 };

	// Type qualifiers are removed in lvalues.
	x = _Generic(*str,
		char: str,
		default: primary_expression
	);
	// Type qualifiers are ignored in rvalues.
	x = _Generic(((const unsigned char)str[2]),
		unsigned char: str
	);
	// Functions are converted to a function pointer.
	x = _Generic(type_conversions,
		void(*)(const char *): str,
		default: primary_expression
	);
	// Arrays are converted to the corresponding pointer.
	x = _Generic(array,
		int *: str,
		default: primary_expression
	);
}


void
skip_blank(const char *p)
{
	static const unsigned short *_ctype_tab_;

	while (_Generic(
	    p[1 / 0],
	    unsigned char: (_ctype_tab_ + 1)[*p] & 0x0200,
	    int: (_ctype_tab_ + 1)[*p] & 0x0200
	))
		p++;
}

const char *
evaluation_mode(void)
{
	return _Generic(
	    0,

	    // Only parse since 'double' does not match 'int'.
	    double: 1 / 0,

	    int: "matched",

	    // Only parse since 'const char *' does not match 'int'.
	    // Plus, 'int' already matched in the previous branch.
	    const char *: 1 / 0,

	    // Only parse since a previous branch already matched,
	    // so the fallback branch is not used.
	    default: 1 / 0
	);
}

const char *
evaluation_mode_early_default(void)
{
	return _Generic(
	    0,

	    // Lint decides at parse time whether it fully evaluates the
	    // branch or only parses it. Since the default branch comes
	    // first, it is not yet known whether any of the other branches
	    // will match, so evaluate it.
	    /* expect+1: error: division by 0 [139] */
	    default: 1 / 0,

	    // Only parse since 'double' does not match 'int'.
	    double: 1 / 0,

	    int: "matched",

	    // Only parse since 'const char *' does not match 'int'.
	    const char *: 1 / 0
	);
}
