/*      $NetBSD: msg_129.c,v 1.11 2025/09/17 19:25:23 rillig Exp $      */
# 3 "msg_129.c"

// Test for message: expression has null effect [129]

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

typedef unsigned char uint8_t;
typedef unsigned int uint32_t;

_Bool side_effect(void);

/*
 * Before tree.c 1.198 from 2021-01-30, the nested comma operators were
 * wrongly reported as having no side effect.
 *
 * The bug was that has_side_effect did not properly examine the sub-nodes.
 * The ',' operator itself has m_has_side_effect == false since it depends
 * on its operands whether the ',' actually has side effects.  For nested ','
 * operators, the function did not evaluate the operands deeply but only did
 * a quick shallow test on the m_has_side_effect property.  Since that is
 * false, lint thought that the whole expression would have no side effect.
 */
void
uint8_buffer_write_uint32(uint8_t *c, uint32_t l)
{
        (*(c++) = (uint8_t)(l & 0xff),
            *(c++) = (uint8_t)((l >> 8L) & 0xff),
            *(c++) = (uint8_t)((l >> 16L) & 0xff),
            *(c++) = (uint8_t)((l >> 24L) & 0xff));
}

void
operator_and(_Bool cond)
{
        cond && side_effect();
        // ... is an abbreviation for ...
        if (cond)
                side_effect();
        // This pattern is much more common in shell or Perl than in C.

        /* expect+1: warning: expression has null effect [129] */
        side_effect() && cond;
}

void
operator_or(_Bool cond)
{
        cond || side_effect();
        // ... is an abbreviation for ...
        if (!cond)
                side_effect();
        // This pattern is much more common in shell or Perl than in C.

        /* expect+1: warning: expression has null effect [129] */
        side_effect() || cond;
}

void
operator_quest_colon(void)
{
        side_effect() ? side_effect() : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        side_effect() ? side_effect() : 0;

        /* expect+1: warning: expression has null effect [129] */
        side_effect() ? 0 : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        side_effect() ? 0 : 1;

        0 ? side_effect() : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        0 ? side_effect() : 0;

        /* expect+1: warning: expression has null effect [129] */
        0 ? 0 : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        0 ? 0 : 1;

        1 ? side_effect() : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        1 ? side_effect() : 0;

        /* expect+1: warning: expression has null effect [129] */
        1 ? 0 : side_effect();

        /* expect+1: warning: expression has null effect [129] */
        1 ? 1 : 0;

        0 ? (void)1 : (void)0;
}

void
operator_comma(void)
{
        side_effect(), 0;               /* the 0 is redundant */
        /* expect+1: warning: expression has null effect [129] */
        0, side_effect();

        if (side_effect(), 0)           /* the 0 controls the 'if' */
                return;
        /* expect+1: warning: expression has null effect [129] */
        if (0, side_effect())
                return;
}

void
legitimate_use_cases(int arg)
{
        int local = 3;

        /*
         * This expression is commonly used to mark the parameter as
         * deliberately unused.
         */
        (void)arg;

        /*
         * This expression is commonly used to mark the local variable as
         * deliberately unused.  This situation occurs when the local
         * variable is only used in some but not all compile-time selectable
         * variants of the code, such as in debugging mode, and writing down
         * the exact conditions would complicate the code unnecessarily.
         */
        (void)local;

        /* This is a shorthand notation for a do-nothing command. */
        (void)0;

        /*
         * At the point where lint checks for expressions having a null
         * effect, constants have been folded, therefore the following
         * expression is considered safe as well.  It does not appear in
         * practice though.
         */
        (void)(3 - 3);

        /*
         * This variant of the do-nothing command is commonly used in
         * preprocessor macros since it works nicely with if-else and if-then
         * statements.  It is longer than the above variant, and it is not
         * embeddable into an expression.
         */
        do {
        } while (0);

        /*
         * Only the expression '(void)0' is common, other expressions are
         * unusual enough to warrant a warning.
         */
        /* expect+1: warning: expression has null effect [129] */
        (void)13;

        /* Double casts are unusual enough to warrant a warning. */
        /* expect+1: warning: expression has null effect [129] */
        (void)(void)0;
}

int
return_statement_expression(int arg)
{
        ({
                int local = arg;
                local + 4;
        /* expect+1: warning: expression has null effect [129] */
        });

        if (arg == 1)
                return ({
                        int local = arg;
                        // Before cgram.y 1.513 from 2024-10-29, lint wrongly
                        // warned that this expression would have a null effect.
                        local;
                });

        if (arg == 2)
                return ({
                        int local = arg;
                        // Before cgram.y 1.513 from 2024-10-29, lint wrongly
                        // warned that this expression would have a null effect.
                        local + 4;
                });

        return 0;
}