/*      $NetBSD: expr_binary.c,v 1.10 2025/04/12 15:49:49 rillig Exp $  */
# 3 "expr_binary.c"

/*
* Test binary operators.
*/

/* lint1-only-if: lp64 */
/* lint1-extra-flags: -X 351 */

struct incompatible {           /* just to generate the error message */
       int member;
};
void sink(struct incompatible);

/*
* Test the usual arithmetic conversions.
*
* C99 6.3.1.8 "Usual arithmetic conversions"
*/
void
cover_balance(void)
{
       /* expect+1: ... 'pointer to void' ... */
       sink((void *)0 + 0);

       /* expect+1: ... 'pointer to void' ... */
       sink(0 + (void *)0);

       /* expect+1: ... 'int' ... */
       sink(1 + 1);

       /* expect+1: ... 'const int' ... */
       sink((const int)1 + (volatile int)1);

       /* expect+1: ... 'volatile int' ... */
       sink((volatile int)1 + (const int)1);

       long double _Complex cldbl = 0.0;
       double _Complex cdbl = 0.0;
       float _Complex cflt = 0.0f;
       /* expect+1: error: invalid type for _Complex [308] */
       _Complex invalid = 0.0;

       /* expect+1: ... 'long double _Complex' ... */
       sink(cldbl + 0);
       /* expect+1: ... 'long double _Complex' ... */
       sink(0 + cldbl);
       /* expect+1: ... 'long double _Complex' ... */
       sink(cldbl + cdbl);
       /* expect+1: ... 'long double _Complex' ... */
       sink(cdbl + cldbl);

       /* expect+1: ... 'double _Complex' ... */
       sink(cdbl + 0);
       /* expect+1: ... 'double _Complex' ... */
       sink(0 + cdbl);
       /* expect+1: ... 'double _Complex' ... */
       sink(cdbl + cflt);
       /* expect+1: ... 'double _Complex' ... */
       sink(cflt + cdbl);

       /* expect+1: ... 'float _Complex' ... */
       sink(cflt + 0);
       /* expect+1: ... 'float _Complex' ... */
       sink(0 + cflt);
       /* expect+1: ... 'float _Complex' ... */
       sink(cflt + (__uint128_t)0);
       /* expect+1: ... 'float _Complex' ... */
       sink((__uint128_t)0 + cflt);

       /*
        * The type specifier '_Complex' is only used during parsing, it does
        * not make it to the expression.
        */
       /* expect+1: ... 'double _Complex' ... */
       sink(invalid + 0);

       /* expect+1: ... 'long double' ... */
       sink(0.0L + 0);
       /* expect+1: ... 'long double' ... */
       sink(0 + 0.0L);
       /* expect+1: ... 'long double' ... */
       sink(0.0L + 0.0);
       /* expect+1: ... 'long double' ... */
       sink(0.0 + 0.0L);

       /* expect+1: ... 'double' ... */
       sink(0.0 + 0);
       /* expect+1: ... 'double' ... */
       sink(0 + 0.0);
       /* expect+1: ... 'double' ... */
       sink(0.0 + 0.0f);
       /* expect+1: ... 'double' ... */
       sink(0.0f + 0.0);

       /* expect+1: ... 'float' ... */
       sink(0.0f + 0);
       /* expect+1: ... 'float' ... */
       sink(0 + 0.0f);
       /* expect+1: ... 'float' ... */
       sink(0.0f + (__uint128_t)0);
       /* expect+1: ... 'float' ... */
       sink((__uint128_t)0 + 0.0f);

       /* expect+1: ... 'unsigned long long' ... */
       sink(0ULL + 0);
       /* expect+1: ... 'unsigned long long' ... */
       sink(0 + 0ULL);

       /* expect+1: ... 'unsigned long long' ... */
       sink(0ULL + 0LL);
       /* expect+1: ... 'unsigned long long' ... */
       sink(0LL + 0ULL);

       /* If the bit-width is the same, prefer the unsigned variant. */
       /* expect+1: ... 'unsigned long long' ... */
       sink(0UL + 0LL);
       /* expect+1: ... 'unsigned long long' ... */
       sink(0LL + 0UL);

       /*
        * Ensure that __int128_t is listed in the integer ranks.  This table
        * only becomes relevant when both operands have the same width.
        */
       /* expect+1: ... '__uint128_t' ... */
       sink((__uint128_t)1 + (__int128_t)1);
       /* expect+1: ... '__uint128_t' ... */
       sink((__int128_t)1 + (__uint128_t)1);
}

struct point {
       int x, y;
};

static void
return_void(void)
{
}

static _Bool
return_bool(void)
{
       return sizeof(char) == 1;
}

static struct point
return_sou(void)
{
       return (struct point){ 0, 0 };
}

static int
return_integer(void)
{
       return 4;
}

static double
return_floating(void)
{
       return 3.5;
}

static char *
return_pointer(void)
{
       return (void *)0;
}

static inline void
op_colon(_Bool cond)
{
       cond ? return_void() : return_void();
       /* expect+1: warning: incompatible types 'void' and '_Bool' in conditional [126] */
       cond ? return_void() : return_bool();
       /* expect+1: warning: incompatible types 'void' and 'struct point' in conditional [126] */
       cond ? return_void() : return_sou();
       /* expect+1: warning: incompatible types 'void' and 'int' in conditional [126] */
       cond ? return_void() : return_integer();
       /* expect+1: warning: incompatible types 'void' and 'double' in conditional [126] */
       cond ? return_void() : return_floating();
       /* expect+1: warning: incompatible types 'void' and 'pointer to char' in conditional [126] */
       cond ? return_void() : return_pointer();
       /* expect+1: warning: incompatible types '_Bool' and 'void' in conditional [126] */
       cond ? return_bool() : return_void();
       cond ? return_bool() : return_bool();
       /* expect+1: error: incompatible types '_Bool' and 'struct point' in conditional [126] */
       cond ? return_bool() : return_sou();
       cond ? return_bool() : return_integer();
       cond ? return_bool() : return_floating();
       /* expect+1: warning: invalid combination of integer '_Bool' and pointer 'pointer to char', op ':' [123] */
       cond ? return_bool() : return_pointer();
       // FIXME: GCC doesn't warn, as the 'type mismatch' is not wrong.
       /* expect+1: warning: incompatible types 'struct point' and 'void' in conditional [126] */
       cond ? return_sou() : return_void();
       /* expect+1: error: incompatible types 'struct point' and '_Bool' in conditional [126] */
       cond ? return_sou() : return_bool();
       cond ? return_sou() : return_sou();
       /* expect+1: error: incompatible types 'struct point' and 'int' in conditional [126] */
       cond ? return_sou() : return_integer();
       /* expect+1: error: incompatible types 'struct point' and 'double' in conditional [126] */
       cond ? return_sou() : return_floating();
       /* expect+1: error: incompatible types 'struct point' and 'pointer to char' in conditional [126] */
       cond ? return_sou() : return_pointer();
       /* expect+1: warning: incompatible types 'int' and 'void' in conditional [126] */
       cond ? return_integer() : return_void();
       cond ? return_integer() : return_bool();
       /* expect+1: error: incompatible types 'int' and 'struct point' in conditional [126] */
       cond ? return_integer() : return_sou();
       cond ? return_integer() : return_integer();
       cond ? return_integer() : return_floating();
       /* expect+1: warning: invalid combination of integer 'int' and pointer 'pointer to char', op ':' [123] */
       cond ? return_integer() : return_pointer();
       /* expect+1: warning: incompatible types 'double' and 'void' in conditional [126] */
       cond ? return_floating() : return_void();
       cond ? return_floating() : return_bool();
       /* expect+1: error: incompatible types 'double' and 'struct point' in conditional [126] */
       cond ? return_floating() : return_sou();
       cond ? return_floating() : return_integer();
       cond ? return_floating() : return_floating();
       /* expect+1: error: incompatible types 'double' and 'pointer to char' in conditional [126] */
       cond ? return_floating() : return_pointer();
       /* expect+1: warning: incompatible types 'pointer to char' and 'void' in conditional [126] */
       cond ? return_pointer() : return_void();
       /* expect+1: warning: invalid combination of pointer 'pointer to char' and integer '_Bool', op ':' [123] */
       cond ? return_pointer() : return_bool();
       /* expect+1: error: incompatible types 'pointer to char' and 'struct point' in conditional [126] */
       cond ? return_pointer() : return_sou();
       /* expect+1: warning: invalid combination of pointer 'pointer to char' and integer 'int', op ':' [123] */
       cond ? return_pointer() : return_integer();
       /* expect+1: error: incompatible types 'pointer to char' and 'double' in conditional [126] */
       cond ? return_pointer() : return_floating();
       cond ? return_pointer() : return_pointer();
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.