WARNING_FILTER += allow categories:LANG.STRUCT.UC
WARNING_FILTER += discard categories:LANG.STRUCT.UC

#include <stdlib.h>
#include <stddef.h>

void g(void);

int f(int i){
    if( i ) exit( i );
    return 0;
}

/* For unreachable_computation(), unreachable_conditional(),
 * unreachable_conditional(), and unreachable_data_flow(), the first
 * statement in the function body is
 *    int rv = f(5);
 *
 * The call to f() is reachable but never returns, so the remainder of
 * the function, including the assignment of the return value to rv
 * that takes place in the same statement, is unreachable. (This
 * assignment is itself a data flow.) The warning class for each of
 * these cases will depend on the nature of the statements in the
 * unreachable block.
 */
int unreachable_call(int x){
    int p;
    int rv = f(5); /* 'Unreachable Call' warning issued here */
    g();                       /* call (highest severity) */
    rv += x;                   /* computation */
    if (x>5) {                 /* conditional */ 
      return 0;                /* data flow */
    }
    p = rv;                    /* data flow */
    return p;
}

int unreachable_computation(int x){
    int p;
    int rv = f(5); /* 'Unreachable Computation' warning issued here */
    rv += x;                   /* computation (highest severity) */   
    if (x>5) {                 /* conditional */ 
      return 0;                /* data flow */
    }
    p = rv;                    /* data flow */
    return p;
}

int unreachable_conditional(int x){
    int p;
    int rv = f(5); /* 'Unreachable Conditional' warning issued here */ 
    if (x>5) {                 /* conditional (highest severity) */ 
      return 0;                /* data flow */
    }
    p = rv;                    /* data flow */
    return p;
}

int unreachable_data_flow(void){
   int p;
   int rv = f(5);  /* 'Unreachable Data Flow' warning issued here */
   p = rv;                    /* data flow */
   return p;
}


/* In unreachable_control_flow(), a return statement is unreachable
 * because it is in the TRUE branch of an IF statement whose condition
 * always evaluates to FALSE.
 */
void unreachable_control_flow(int x, int y){
    char *q = NULL;
    while (q==NULL){
       q = (char *) malloc(5 * sizeof(char));
    }
    if (q==NULL) {                       /* ('Redundant Condition' warning issued here) */
        return;    /* 'Unreachable Control Flow' warning issued here */
    }
    free(q);
}