/*      $NetBSD: msg_193.c,v 1.22 2024/11/13 04:32:49 rillig Exp $      */
# 3 "msg_193.c"

// Test for message: '%s' statement not reached [193]

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

/*
* Test the reachability of statements in a function.
*
*      if
*      if-else
*      if-else-if-else
*      for
*      while
*      do-while
*      switch
*      break
*      continue
*      goto
*      return
*
*      constant expression
*      system-dependent constant expression
*/

extern void reachable(void);
extern void unreachable(void);
extern _Bool maybe(void);


void
test_statement(void)
{
       reachable();
       reachable();
}

void
test_compound_statement(void)
{
       reachable();
       {
               reachable();
               reachable();
       }
       reachable();
}

void
test_if_statement(void)
{
       if (1)
               reachable();
       reachable();
       if (0)
               unreachable();          /* expect+0: ... [193] */
       reachable();
}

void
test_if_compound_statement(void)
{
       if (1) {
               reachable();
       }
       if (1) {
               {
                       {
                               reachable();
                       }
               }
       }

       if (0) {
               unreachable();          /* expect+0: ... [193] */
       }
       if (0) {
               {
                       {
                               unreachable();  /* expect+0: ... [193] */
                       }
               }
       }
}

void
test_if_without_else(void)
{
       if (1)
               reachable();
       reachable();

       if (0)
               unreachable();          /* expect+0: ... [193] */
       reachable();
}

void
test_if_with_else(void)
{
       if (1)
               reachable();
       else
               unreachable();          /* expect+0: ... [193] */
       reachable();

       if (0)
               unreachable();          /* expect+0: ... [193] */
       else
               reachable();
       reachable();
}

void
test_if_else_if_else(void)
{
       if (1)
               reachable();
       else if (1)                     /* expect+0: ... [193] */
               unreachable();
       else
               unreachable();          /* expect+0: ... [193] */

       if (0)
               unreachable();          /* expect+0: ... [193] */
       else if (1)
               reachable();
       else
               unreachable();          /* expect+0: ... [193] */

       if (0)
               unreachable();          /* expect+0: ... [193] */
       else if (0)
               unreachable();          /* expect+0: ... [193] */
       else
               reachable();
}

void
test_if_return(void)
{
       if (1)
               return;
       unreachable();                  /* expect+0: ... [193] */
}

void
test_if_else_return(void)
{
       if (1)
               reachable();
       else
               return;                 /* expect+0: ... [193] */
       reachable();
}

void
test_for_forever(void)
{
       for (;;)
               reachable();
       unreachable();                  /* expect+0: ... [193] */
}

void
test_for_true(void)
{
       for (; 1;)
               reachable();
       unreachable();                  /* expect+0: ... [193] */
}

void
test_for_false(void)
{
       for (; 0;)
               unreachable();          /* expect+0: ... [193] */
       reachable();
}

void
test_for_break(void)
{
       for (;;) {
               reachable();
               break;
               unreachable();          /* expect+0: ... [193] */
       }
       reachable();
}

void
test_for_if_break(void)
{
       for (;;) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       reachable();
}

void
test_for_continue(void)
{
       for (;;) {
               reachable();
               continue;
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_for_if_continue(void)
{
       for (;;) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_for_return(void)
{
       for (;;) {
               reachable();
               return;
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_for_if_return(void)
{
       for (;;) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_while_true(void)
{
       while (1)
               reachable();
       unreachable();                  /* expect+0: ... [193] */
}

void
test_while_false(void)
{
       while (0)
               unreachable();          /* expect+0: ... [193] */
       reachable();
}

void
test_while_break(void)
{
       while (1) {
               reachable();
               break;
               unreachable();          /* expect+0: ... [193] */
       }
       reachable();
}

void
test_while_if_break(void)
{
       while (1) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       reachable();
}

void
test_while_continue(void)
{
       while (1) {
               reachable();
               continue;
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_while_if_continue(void)
{
       while (1) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_while_return(void)
{
       while (1) {
               reachable();
               return;
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_while_if_return(void)
{
       while (1) {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       }
       unreachable();                  /* expect+0: ... [193] */
}

void
test_do_while_true(void)
{
       do {
               reachable();
       } while (1);
       unreachable();                  /* expect+0: ... [193] */
}

void
test_do_while_false(void)
{
       do {
               reachable();
       } while (0);
       reachable();
}

void
test_do_while_break(void)
{
       do {
               reachable();
               break;
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       reachable();
}

void
test_do_while_if_break(void)
{
       do {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       break;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       reachable();
}

void
test_do_while_continue(void)
{
       do {
               reachable();
               continue;
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       unreachable();                  /* expect+0: ... [193] */
}

void
test_do_while_if_continue(void)
{
       do {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       continue;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       unreachable();                  /* expect+0: ... [193] */
}

void
test_do_while_return(void)
{
       do {
               reachable();
               return;
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       unreachable();                  /* expect+0: ... [193] */
}

void
test_do_while_if_return(void)
{
       do {
               reachable();
               if (0) {
                       unreachable();  /* expect+0: ... [193] */
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               if (1) {
                       reachable();
                       return;
                       unreachable();  /* expect+0: ... [193] */
               }
               unreachable();          /* expect+0: ... [193] */
       } while (1);
       unreachable();                  /* expect+0: ... [193] */
}

void
test_if_nested(void)
{
       if (0) {
               if (1)                  /* expect+0: ... [193] */
                       unreachable();
               else
                       unreachable();  /* expect+0: ... [193] *//* XXX: redundant */

               if (0)
                       unreachable();  /* expect+0: ... [193] *//* XXX: redundant */
               else
                       unreachable();

               unreachable();
       }
       reachable();

       if (1) {
               if (1)
                       reachable();
               else
                       unreachable();  /* expect+0: ... [193] */

               if (0)
                       unreachable();  /* expect+0: ... [193] */
               else
                       reachable();

               reachable();
       }
       reachable();
}

void
test_if_maybe(void)
{
       if (maybe()) {
               if (0)
                       unreachable();  /* expect+0: ... [193] */
               else
                       reachable();
               reachable();
       }
       reachable();

       if (0) {
               if (maybe())            /* expect+0: ... [193] */
                       unreachable();
               else
                       unreachable();
               unreachable();
       }
       reachable();

       if (1) {
               if (maybe())
                       reachable();
               else
                       reachable();
               reachable();
       }
       reachable();
}

/*
* To compute the reachability graph of this little monster, lint would have
* to keep all statements and their relations from the whole function in
* memory.  It doesn't do that.  Therefore it does not warn about any
* unreachable statements in this function.
*/
void
test_goto_numbers_alphabetically(void)
{
       goto one;
eight:
       goto nine;
five:
       return;
four:
       goto five;
nine:
       goto ten;
one:
       goto two;
seven:
       goto eight;
six:
       /* expect-1: warning: label 'six' unused in function 'test_goto_numbers_alphabetically' [232] */
       goto seven;
ten:
       return;
three:
       goto four;
two:
       goto three;
}

void
test_while_goto(void)
{
       while (1) {
               goto out;
               break;          /* lint only warns with the -b option */
       }
       unreachable();          /* expect+0: ... [193] */
out:
       reachable();
}

void
test_unreachable_label(void)
{
       if (0)
               goto unreachable;       /* expect+0: ... [193] */
       goto reachable;

       /* named_label assumes that any label is reachable. */
unreachable:
       unreachable();
reachable:
       reachable();
}

/* TODO: switch */

/* TODO: system-dependent constant expression (see tn_system_dependent) */

void suppressed(void);

void
lint_annotation_NOTREACHED(void)
{
       if (0) {
               /* expect+1: warning: 'call' statement not reached [193] */
               unreachable();
       }

       if (0) {
               /* NOTREACHED */
               suppressed();
       }

       if (0)
               /* NOTREACHED */
               suppressed();

       if (1) {
               reachable();
       }

       if (1) {
               /* NOTREACHED */
               suppressed();
       }

       /*
        * Since the condition in the 'if' statement is constant, lint knows
        * that the branch is unconditionally taken.  The annotation comment
        * marks that branch as not reached, which means that any following
        * statement cannot be reached as well.
        */
       /* expect+1: warning: 'if' statement not reached [193] */
       if (1)
               /* NOTREACHED */
               suppressed();
}

/*
* Since at least 2002 and before cgram.y 1.379 from 2022-01-16, lint did not
* detect a double semicolon.  See cgram.y, expression_statement, T_SEMI.
*/
int
test_null_statement(void)
{
       /*
        * The following 2 semicolons are superfluous but lint doesn't warn
        * about them.  Probably it should.  A null statement as part of a
        * block-list has no use.
        */
       ;;

       /*
        * If assertions are disabled with -DNDEBUG and __lint__ is defined,
        * NetBSD's <assert.h> defines assert(x) to nothing, leaving only
        * the trailing semicolon.  If there are several assertions next to
        * each other, without any whitespace in between (very unusual), the
        * GCC preprocessor generates ";;" for them, which makes them
        * indistinguishable from the literal ";;" from the typo above.
        *
        * (echo '#include <assert.h>'; echo 'assert(0);assert(1);') \
        * | gcc -DNDEBUG -E - -D__lint__
        *
        * To actually see the difference, lint would need to look at the
        * code before preprocessing and compare it with the preprocessed
        * code, which would be a lot of work.
        *
        * Apart from the above edge case, detecting extra semicolons would
        * be possible, but lint would have to look at the whitespace between
        * the tokens, and this is something that it doesn't do at all, as of
        * 2022-01-16.
        */

       /*
        * A stand-alone null statement, on the other hand, has its purpose.
        * Without it, the 'for' loop would not be complete.  The NetBSD
        * style is to use 'continue;' instead of a simple ';'.
        */
       for (int i = 0; i < 10; i++)
               ;

       /* expect+1: warning: 'empty' statement not reached [193] */
       return 0;;
}

/*
* Before func.c 1.149 from 2023-02-21, lint crashed due to a null pointer
* dereference.
*/
void
invalid_case_expression(void)
{
       switch (4) {
       /* expect+1: error: operand of '~' has invalid type 'double' [108] */
       case ~0.0:
               ;
       }
}

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.