/*
 * Copyright (C) 2014 Oracle.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
 */

#include "smatch.h"

static int my_id;

static int print_unreached = 1;
static struct string_list *turn_off_names;
static struct string_list *ignore_names;

static int empty_statement(struct statement *stmt)
{
        if (!stmt)
                return 0;
        if (stmt->type == STMT_EXPRESSION && !stmt->expression)
                return 1;
        return 0;
}

static int is_last_stmt(struct statement *cur_stmt)
{
        struct symbol *fn = get_base_type(cur_func_sym);
        struct statement *stmt;

        if (!fn)
                return 0;
        stmt = fn->stmt;
        if (!stmt)
                stmt = fn->inline_stmt;
        if (!stmt || stmt->type != STMT_COMPOUND)
                return 0;
        stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
        if (stmt == cur_stmt)
                return 1;
        return 0;
}

static void print_unreached_initializers(struct symbol_list *sym_list)
{
        struct symbol *sym;

        FOR_EACH_PTR(sym_list, sym) {
                if (sym->initializer && !(sym->ctype.modifiers & MOD_STATIC))
                        sm_msg("info: '%s' is not actually initialized (unreached code).",
                                (sym->ident ? sym->ident->name : "this variable"));
        } END_FOR_EACH_PTR(sym);
}

static int is_ignored_macro(struct statement *stmt)
{
        char *name;
        char *tmp;

        name = get_macro_name(stmt->pos);
        if (!name)
                return 0;

        FOR_EACH_PTR(ignore_names, tmp) {
                if (strcmp(tmp, name) == 0)
                        return 1;
        } END_FOR_EACH_PTR(tmp);

        return 0;
}

static int prev_line_was_endif(struct statement *stmt)
{
        struct token *token;
        struct position pos = stmt->pos;

        pos.line--;
        pos.pos = 2;

        token = pos_get_token(pos);
        if (token && token_type(token) == TOKEN_IDENT &&
            strcmp(show_ident(token->ident), "endif") == 0)
                return 1;

        pos.line--;
        token = pos_get_token(pos);
        if (token && token_type(token) == TOKEN_IDENT &&
            strcmp(show_ident(token->ident), "endif") == 0)
                return 1;

        return 0;
}

static int we_jumped_into_the_middle_of_a_loop(struct statement *stmt)
{
        struct statement *prev;

        /*
         * Smatch doesn't handle loops correctly and this is a hack.  What we
         * do is that if the first unreachable statement is a loop and the
         * previous statement was a goto then it's probably code like this:
         *      goto first;
         *      for (;;) {
         *              frob();
         * first:
         *              more_frob();
         *      }
         * Every statement is reachable but only on the second iteration.
         */

        if (stmt->type != STMT_ITERATOR)
                return 0;
        prev = get_prev_statement();
        if (prev && prev->type == STMT_GOTO)
                return 1;
        return 0;
}

static void unreachable_stmt(struct statement *stmt)
{

        if (__inline_fn)
                return;

        if (!__path_is_null()) {
                print_unreached = 1;
                return;
        }

        /* if we hit a label then assume there is a matching goto */
        if (stmt->type == STMT_LABEL)
                print_unreached = 0;
        if (prev_line_was_endif(stmt))
                print_unreached = 0;
        if (we_jumped_into_the_middle_of_a_loop(stmt))
                print_unreached = 0;

        if (!print_unreached)
                return;
        if (empty_statement(stmt))
                return;
        if (is_ignored_macro(stmt))
                return;

        switch (stmt->type) {
        case STMT_COMPOUND: /* after a switch before a case stmt */
        case STMT_RANGE:
        case STMT_CASE:
                return;
        case STMT_DECLARATION: /* switch (x) { int a; case foo: ... */
                print_unreached_initializers(stmt->declaration);
                return;
        case STMT_RETURN: /* gcc complains if you don't have a return statement */
                if (is_last_stmt(stmt))
                        return;
                break;
        case STMT_GOTO:
                /* people put extra breaks inside switch statements */
                if (stmt->goto_label && stmt->goto_label->type == SYM_NODE &&
                    strcmp(stmt->goto_label->ident->name, "break") == 0)
                        return;
                break;
        default:
                break;
        }
        sm_warning("ignoring unreachable code.");
        print_unreached = 0;
}

static int is_turn_off(char *name)
{
        char *tmp;

        if (!name)
                return 0;

        FOR_EACH_PTR(turn_off_names, tmp) {
                if (strcmp(tmp, name) == 0)
                        return 1;
        } END_FOR_EACH_PTR(tmp);

        return 0;
}

static char *get_function_name(struct statement *stmt)
{
        struct expression *expr;

        if (stmt->type != STMT_EXPRESSION)
                return NULL;
        expr = stmt->expression;
        if (!expr || expr->type != EXPR_CALL)
                return NULL;
        if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol_name)
                return NULL;
        return expr->fn->symbol_name->name;
}

static void turn_off_unreachable(struct statement *stmt)
{
        char *name;

        name = get_macro_name(stmt->pos);
        if (is_turn_off(name)) {
                print_unreached = 0;
                return;
        }

        if (stmt->type == STMT_IF &&
            known_condition_true(stmt->if_conditional) &&  __path_is_null()) {
                print_unreached = 0;
                return;
        }

        name = get_function_name(stmt);
        if (is_turn_off(name))
                print_unreached = 0;
}

static void register_turn_off_macros(void)
{
        struct token *token;
        char *macro;
        char name[256];

        if (option_project == PROJ_NONE)
                strcpy(name, "unreachable.turn_off");
        else
                snprintf(name, 256, "%s.unreachable.turn_off", option_project_str);

        token = get_tokens_file(name);
        if (!token)
                return;
        if (token_type(token) != TOKEN_STREAMBEGIN)
                return;
        token = token->next;
        while (token_type(token) != TOKEN_STREAMEND) {
                if (token_type(token) != TOKEN_IDENT)
                        return;
                macro = alloc_string(show_ident(token->ident));
                add_ptr_list(&turn_off_names, macro);
                token = token->next;
        }
        clear_token_alloc();
}

static void register_ignored_macros(void)
{
        struct token *token;
        char *macro;
        char name[256];

        if (option_project == PROJ_NONE)
                strcpy(name, "unreachable.ignore");
        else
                snprintf(name, 256, "%s.unreachable.ignore", option_project_str);

        token = get_tokens_file(name);
        if (!token)
                return;
        if (token_type(token) != TOKEN_STREAMBEGIN)
                return;
        token = token->next;
        while (token_type(token) != TOKEN_STREAMEND) {
                if (token_type(token) != TOKEN_IDENT)
                        return;
                macro = alloc_string(show_ident(token->ident));
                add_ptr_list(&ignore_names, macro);
                token = token->next;
        }
        clear_token_alloc();
}

void check_unreachable(int id)
{
        my_id = id;

        register_turn_off_macros();
        register_ignored_macros();
        add_hook(&unreachable_stmt, STMT_HOOK);
        add_hook(&turn_off_unreachable, STMT_HOOK_AFTER);
}