/*
 * Copyright (C) 2011 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"
#include "smatch_slist.h"
#include "smatch_extra.h"

int RETURN_ID;

struct return_states_callback {
	void (*callback)(void);
};
ALLOCATOR(return_states_callback, "return states callbacks");
DECLARE_PTR_LIST(callback_list, struct return_states_callback);
static struct callback_list *callback_list;

DECLARE_PTR_LIST(stree_stack_stack, struct stree_stack);
static void push_stree_stack(struct stree_stack_stack **stack_stack, struct stree_stack *stack)
{
	add_ptr_list(stack_stack, stack);
}

static struct stree_stack *pop_stree_stack(struct stree_stack_stack **stack_stack)
{
	struct stree_stack *stack;

	stack = last_ptr_list((struct ptr_list *)*stack_stack);
	delete_ptr_list_last((struct ptr_list **)stack_stack);
	return stack;
}

static struct stree_stack *return_stree_stack;
static struct stree_stack_stack *saved_stack_stack;
static struct stree *all_return_states;
static struct stree_stack *saved_stack;

void all_return_states_hook(void (*callback)(void))
{
	struct return_states_callback *rs_cb = __alloc_return_states_callback(0);

	rs_cb->callback = callback;
	add_ptr_list(&callback_list, rs_cb);
}

static void call_hooks(void)
{
	struct return_states_callback *rs_cb;
	struct stree *orig;

	orig = __swap_cur_stree(all_return_states);
	FOR_EACH_PTR(callback_list, rs_cb) {
		rs_cb->callback();
	} END_FOR_EACH_PTR(rs_cb);
	__swap_cur_stree(orig);
}

static void match_return(int return_id, char *return_ranges, struct expression *expr)
{
	struct stree *stree;

	stree = clone_stree(__get_cur_stree());
	merge_stree_no_pools(&all_return_states, stree);
	push_stree(&return_stree_stack, stree);
}

static void match_end_func(struct symbol *sym)
{
	/*
	 * FIXME: either this isn't needed or we need to copy a stree into the
	 * return_stree_stack as well.
	 */
	merge_stree(&all_return_states, __get_cur_stree());
	call_hooks();
}

static void match_save_states(struct expression *expr)
{
	push_stree(&saved_stack, all_return_states);
	all_return_states = NULL;

	push_stree_stack(&saved_stack_stack, return_stree_stack);
	return_stree_stack = NULL;
}

static void match_restore_states(struct expression *expr)
{
	/* This free_stree() isn't needed is it?? */
	free_stree(&all_return_states);

	all_return_states = pop_stree(&saved_stack);
	return_stree_stack = pop_stree_stack(&saved_stack_stack);
}

struct stree *get_all_return_states(void)
{
	return all_return_states;
}

struct stree_stack *get_all_return_strees(void)
{
	return return_stree_stack;
}

static void free_resources(struct symbol *sym)
{
	free_stree(&all_return_states);
	free_stack_and_strees(&return_stree_stack);
}

void register_returns_early(int id)
{
	RETURN_ID = id;

	set_dynamic_states(RETURN_ID);
	add_split_return_callback(match_return);
}

void register_returns(int id)
{
	add_hook(&match_end_func, END_FUNC_HOOK);
	add_hook(&match_save_states, INLINE_FN_START);
	add_hook(&match_restore_states, INLINE_FN_END);
	add_hook(&free_resources, AFTER_FUNC_HOOK);
}