/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#include "config.hpp"
#include "compiler.hpp"
#include "annotation.hpp"
#include "vm.hpp"

#include <boost/foreach.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/assert.hpp>
#include <boost/lexical_cast.hpp>
#include <set>

namespace client { namespace code_gen
{
    value::value()
      : v(0),
        is_lvalue_(false),
        builder(0)
    {}

    value::value(
        llvm::Value* v,
        bool is_lvalue_,
        llvm::IRBuilder<>* builder)
      : v(v),
        is_lvalue_(is_lvalue_),
        builder(builder)
    {}

    value::value(value const& rhs)
      : v(rhs.v),
        is_lvalue_(rhs.is_lvalue_),
        builder(rhs.builder)
    {}

    bool value::is_lvalue() const
    {
        return is_lvalue_;
    }

    bool value::is_valid() const
    {
        return v != 0;
    }

    value::operator bool() const
    {
        return v != 0;
    }

    void value::name(char const* id)
    {
        v->setName(id);
    }

    void value::name(std::string const& id)
    {
        v->setName(id);
    }

    value::operator llvm::Value*() const
    {
        if (is_lvalue_)
        {
            BOOST_ASSERT(builder != 0);
            return builder->CreateLoad(v, v->getName());
        }
        return v;
    }

    value& value::operator=(value const& rhs)
    {
        v = rhs.v;
        is_lvalue_ = rhs.is_lvalue_;
        builder = rhs.builder;
        return *this;
    }

    value& value::assign(value const& rhs)
    {
        BOOST_ASSERT(is_lvalue());
        BOOST_ASSERT(builder != 0);
        builder->CreateStore(rhs, v);
        return *this;
    }

    value operator-(value a)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateNeg(a, "neg_tmp"),
            false, a.builder
        );
    }

    value operator!(value a)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateNot(a, "not_tmp"),
            false, a.builder
        );
    }

    value operator+(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateAdd(a, b, "add_tmp"),
            false, a.builder
        );
    }

    value operator-(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateSub(a, b, "sub_tmp"),
            false, a.builder
        );
    }

    value operator*(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateMul(a, b, "mul_tmp"),
            false, a.builder
        );
    }

    value operator/(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateSDiv(a, b, "div_tmp"),
            false, a.builder
        );
    }

    value operator%(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateSRem(a, b, "mod_tmp"),
            false, a.builder
        );
    }

    value operator&(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateAnd(a, b, "and_tmp"),
            false, a.builder
        );
    }

    value operator|(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateOr(a, b, "or_tmp"),
            false, a.builder
        );
    }

    value operator^(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateXor(a, b, "xor_tmp"),
            false, a.builder
        );
    }

    value operator<<(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateShl(a, b, "shl_tmp"),
            false, a.builder
        );
    }

    value operator>>(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateLShr(a, b, "shr_tmp"),
            false, a.builder
        );
    }

    value operator==(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpEQ(a, b, "eq_tmp"),
            false, a.builder
        );
    }

    value operator!=(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpNE(a, b, "ne_tmp"),
            false, a.builder
        );
    }

    value operator<(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpSLT(a, b, "slt_tmp"),
            false, a.builder
        );
    }

    value operator<=(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpSLE(a, b, "sle_tmp"),
            false, a.builder
        );
    }

    value operator>(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpSGT(a, b, "sgt_tmp"),
            false, a.builder
        );
    }

    value operator>=(value a, value b)
    {
        BOOST_ASSERT(a.builder != 0);
        return value(
            a.builder->CreateICmpSGE(a, b, "sge_tmp"),
            false, a.builder
        );
    }

    struct function::to_value
    {
        typedef value result_type;
        llvm_compiler* c;

        to_value(llvm_compiler* c = 0) : c(c) {}

        value operator()(llvm::Value& v) const
        {
            return c->val(&v);
        }
    };

    bool basic_block::has_terminator() const
    {
        return b->getTerminator() != 0;
    }

    bool basic_block::is_valid() const
    {
        return b != 0;
    }

    function::operator llvm::Function*() const
    {
        return f;
    }

    std::size_t function::arg_size() const
    {
        return f->arg_size();
    }

    void function::add(basic_block const& b)
    {
        f->getBasicBlockList().push_back(b);
    }

    void function::erase_from_parent()
    {
        f->eraseFromParent();
    }

    basic_block function::last_block()
    {
        return &f->getBasicBlockList().back();
    }

    bool function::empty() const
    {
        return f->empty();
    }

    std::string function::name() const
    {
        return f->getName();
    }

    function::arg_range function::args() const
    {
        BOOST_ASSERT(c != 0);
        arg_val_iterator first(f->arg_begin(), to_value());
        arg_val_iterator last(f->arg_end(), to_value());
        return arg_range(first, last);
    }

    bool function::is_valid() const
    {
        return f != 0;
    }

    void function::verify() const
    {
        llvm::verifyFunction(*f);
    }

    value llvm_compiler::val(unsigned int x)
    {
        return value(
            llvm::ConstantInt::get(context(), llvm::APInt(int_size, x)),
            false, &llvm_builder);
    }

    value llvm_compiler::val(int x)
    {
        return value(
            llvm::ConstantInt::get(context(), llvm::APInt(int_size, x)),
            false, &llvm_builder);
    }

    value llvm_compiler::val(bool x)
    {
        return value(
            llvm::ConstantInt::get(context(), llvm::APInt(1, x)),
            false, &llvm_builder);
    }

    value llvm_compiler::val(llvm::Value* v)
    {
        return value(v, false, &llvm_builder);
    }

    namespace
    {
        //  Create an alloca instruction in the entry block of
        //  the function. This is used for mutable variables etc.
        llvm::AllocaInst*
        make_entry_block_alloca(
            llvm::Function* f,
            char const* name,
            llvm::LLVMContext& context)
        {
            llvm::IRBuilder<> builder(
                &f->getEntryBlock(),
                f->getEntryBlock().begin());

            return builder.CreateAlloca(
                llvm::Type::getIntNTy(context, int_size), 0, name);
        }
    }

    value llvm_compiler::var(char const* name)
    {
        llvm::Function* f = llvm_builder.GetInsertBlock()->getParent();
        llvm::IRBuilder<> builder(
            &f->getEntryBlock(),
            f->getEntryBlock().begin());

        llvm::AllocaInst* alloca = builder.CreateAlloca(
            llvm::Type::getIntNTy(context(), int_size), 0, name);

        return value(alloca, true, &llvm_builder);
    }

    struct value::to_llvm_value
    {
        typedef llvm::Value* result_type;
        llvm::Value* operator()(value const& x) const
        {
            return x;
        }
    };

    template <typename C>
    llvm::Value* llvm_compiler::call_impl(
        function callee,
        C const& args_)
    {
        // Sigh. LLVM requires CreateCall arguments to be random access.
        // It would have been better if it can accept forward iterators.
        // I guess it needs the arguments to be in contiguous memory.
        // So, we have to put the args into a temporary std::vector.
        std::vector<llvm::Value*> args(
            args_.begin(), args_.end());

        // Check the args for null values. We can't have null values.
        // Return 0 if we find one to flag error.
        BOOST_FOREACH(llvm::Value* arg, args)
        {
            if (arg == 0)
                return 0;
        }

        return llvm_builder.CreateCall(
            callee, args.begin(), args.end(), "call_tmp");
    }

    template <typename Container>
    value llvm_compiler::call(
        function callee,
        Container const& args)
    {
        llvm::Value* call = call_impl(
            callee,
            args | boost::adaptors::transformed(value::to_llvm_value()));

        if (call == 0)
            return val();
        return value(call, false, &llvm_builder);
    }

    function llvm_compiler::get_function(char const* name)
    {
        return function(vm.module()->getFunction(name), this);
    }

    function llvm_compiler::get_current_function()
    {
        // get the current function
        return function(llvm_builder.GetInsertBlock()->getParent(), this);
    }

    function llvm_compiler::declare_function(
        bool void_return
      , std::string const& name
      , std::size_t nargs)
    {
        llvm::Type const* int_type =
            llvm::Type::getIntNTy(context(), int_size);
        llvm::Type const* void_type = llvm::Type::getVoidTy(context());

        std::vector<llvm::Type const*> ints(nargs, int_type);
        llvm::Type const* return_type = void_return ? void_type : int_type;

        llvm::FunctionType* function_type =
            llvm::FunctionType::get(void_return ? void_type : int_type, ints, false);

        return function(llvm::Function::Create(
                function_type, llvm::Function::ExternalLinkage,
                name, vm.module()), this);
    }

    basic_block llvm_compiler::make_basic_block(
        char const* name
      , function parent
      , basic_block before)
    {
        return llvm::BasicBlock::Create(context(), name, parent, before);
    }

    value llvm_compiler::var(std::string const& name)
    {
        return var(name.c_str());
    }

    function llvm_compiler::get_function(std::string const& name)
    {
        return get_function(name.c_str());
    }

    basic_block llvm_compiler::get_insert_block()
    {
        return llvm_builder.GetInsertBlock();
    }

    void llvm_compiler::set_insert_point(basic_block b)
    {
        llvm_builder.SetInsertPoint(b);
    }

    void llvm_compiler::conditional_branch(
        value cond, basic_block true_br, basic_block false_br)
    {
        llvm_builder.CreateCondBr(cond, true_br, false_br);
    }

    void llvm_compiler::branch(basic_block b)
    {
        llvm_builder.CreateBr(b);
    }

    void llvm_compiler::return_()
    {
        llvm_builder.CreateRetVoid();
    }

    void llvm_compiler::return_(value v)
    {
        llvm_builder.CreateRet(v);
    }

    void llvm_compiler::optimize_function(function f)
    {
        // Optimize the function.
        fpm.run(*f);
    }

    void llvm_compiler::init_fpm()
    {
        // Set up the optimizer pipeline.  Start with registering info about how the
        // target lays out data structures.
        fpm.add(new llvm::TargetData(*vm.execution_engine()->getTargetData()));
        // Provide basic AliasAnalysis support for GVN.
        fpm.add(llvm::createBasicAliasAnalysisPass());
        // Promote allocas to registers.
        fpm.add(llvm::createPromoteMemoryToRegisterPass());
        // Do simple "peephole" optimizations and bit-twiddling optzns.
        fpm.add(llvm::createInstructionCombiningPass());
        // Reassociate expressions.
        fpm.add(llvm::createReassociatePass());
        // Eliminate Common SubExpressions.
        fpm.add(llvm::createGVNPass());
        // Simplify the control flow graph (deleting unreachable blocks, etc).
        fpm.add(llvm::createCFGSimplificationPass());

        fpm.doInitialization();
    }

    value compiler::operator()(unsigned int x)
    {
        return val(x);
    }

    value compiler::operator()(bool x)
    {
        return val(x);
    }

    value compiler::operator()(ast::primary_expr const& x)
    {
        return boost::apply_visitor(*this, x.get());
    }

    value compiler::operator()(ast::identifier const& x)
    {
        // Look this variable up in the function.
        if (locals.find(x.name) == locals.end())
        {
            error_handler(x.id, "Undeclared variable: " + x.name);
            return val();
        }
        return locals[x.name];
    }

    value compiler::operator()(ast::unary_expr const& x)
    {
        value operand = boost::apply_visitor(*this, x.operand_);
        if (!operand.is_valid())
            return val();

        switch (x.operator_)
        {
            case token_ids::compl_:     return operand ^ val(-1);
            case token_ids::minus:      return -operand;
            case token_ids::not_:       return !operand;
            case token_ids::plus:       return operand;
            case token_ids::plus_plus:
            {
                if (!operand.is_lvalue())
                {
                    error_handler(x.id, "++ needs an var");
                    return val();
                }

                value r = operand + val(1);
                operand.assign(r);
                return operand;
            }
            case token_ids::minus_minus:
            {
                if (!operand.is_lvalue())
                {
                    error_handler(x.id, "-- needs an var");
                    return val();
                }

                value r = operand - val(1);
                operand.assign(r);
                return operand;
            }
            default:
                BOOST_ASSERT(0);
                return val();
        }
    }

    namespace
    {
        struct compile_args
        {
            compiler& c;
            compile_args(compiler& c) : c(c) {}

            typedef value result_type;
            value operator()(ast::expression const& expr) const
            {
                return c(expr);
            }
        };
    }

    value compiler::operator()(ast::function_call const& x)
    {
        function callee = get_function(x.function_name.name);
        if (!callee.is_valid())
        {
            error_handler(x.function_name.id,
                "Function not found: " + x.function_name.name);
            return val();
        }

        if (callee.arg_size() != x.args.size())
        {
            error_handler(x.function_name.id,
                "Wrong number of arguments: " + x.function_name.name);
            return val();
        }

        return call(callee,
            x.args | boost::adaptors::transformed(compile_args(*this)));
    }

    namespace
    {
        int precedence[] = {
            // precedence 1
            1, // op_comma

            // precedence 2
            2, // op_assign
            2, // op_plus_assign
            2, // op_minus_assign
            2, // op_times_assign
            2, // op_divide_assign
            2, // op_mod_assign
            2, // op_bit_and_assign
            2, // op_bit_xor_assign
            2, // op_bitor_assign
            2, // op_shift_left_assign
            2, // op_shift_right_assign

            // precedence 3
            3, // op_logical_or

            // precedence 4
            4, // op_logical_and

            // precedence 5
            5, // op_bit_or

            // precedence 6
            6, // op_bit_xor

            // precedence 7
            7, // op_bit_and

            // precedence 8
            8, // op_equal
            8, // op_not_equal

            // precedence 9
            9, // op_less
            9, // op_less_equal
            9, // op_greater
            9, // op_greater_equal

            // precedence 10
            10, // op_shift_left
            10, // op_shift_right

            // precedence 11
            11, // op_plus
            11, // op_minus

            // precedence 12
            12, // op_times
            12, // op_divide
            12 // op_mod
        };
    }

    inline int precedence_of(token_ids::type op)
    {
        return precedence[op & 0xFF];
    }

    value compiler::compile_binary_expression(
        value lhs, value rhs, token_ids::type op)
    {
        switch (op)
        {
            case token_ids::plus:           return lhs + rhs;
            case token_ids::minus:          return lhs - rhs;
            case token_ids::times:          return lhs * rhs;
            case token_ids::divide:         return lhs / rhs;
            case token_ids::mod:            return lhs % rhs;

            case token_ids::logical_or:
            case token_ids::bit_or:         return lhs | rhs;

            case token_ids::logical_and:
            case token_ids::bit_and:        return lhs & rhs;

            case token_ids::bit_xor:        return lhs ^ rhs;
            case token_ids::shift_left:     return lhs << rhs;
            case token_ids::shift_right:    return lhs >> rhs;

            case token_ids::equal:          return lhs == rhs;
            case token_ids::not_equal:      return lhs != rhs;
            case token_ids::less:           return lhs < rhs;
            case token_ids::less_equal:     return lhs <= rhs;
            case token_ids::greater:        return lhs > rhs;
            case token_ids::greater_equal:  return lhs >= rhs;

            default: BOOST_ASSERT(0);       return val();
        }
    }

    // The Shunting-yard algorithm
    value compiler::compile_expression(
        int min_precedence,
        value lhs,
        std::list<ast::operation>::const_iterator& rest_begin,
        std::list<ast::operation>::const_iterator rest_end)
    {
        while ((rest_begin != rest_end) &&
            (precedence_of(rest_begin->operator_) >= min_precedence))
        {
            token_ids::type op = rest_begin->operator_;
            value rhs = boost::apply_visitor(*this, rest_begin->operand_);
            if (!rhs.is_valid())
                return val();
            ++rest_begin;

            while ((rest_begin != rest_end) &&
                (precedence_of(rest_begin->operator_) > precedence_of(op)))
            {
                token_ids::type next_op = rest_begin->operator_;
                rhs = compile_expression(
                    precedence_of(next_op), rhs, rest_begin, rest_end);
            }

            lhs = compile_binary_expression(lhs, rhs, op);
        }
        return lhs;
    }

    value compiler::operator()(ast::expression const& x)
    {
        value lhs = boost::apply_visitor(*this, x.first);
        if (!lhs.is_valid())
            return val();
        std::list<ast::operation>::const_iterator rest_begin = x.rest.begin();
        return compile_expression(0, lhs, rest_begin, x.rest.end());
    }

    value compiler::operator()(ast::assignment const& x)
    {
        if (locals.find(x.lhs.name) == locals.end())
        {
            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
            return val();
        }

        value lhs = locals[x.lhs.name];
        value rhs = (*this)(x.rhs);
        if (!rhs.is_valid())
            return val();

        if (x.operator_ == token_ids::assign)
        {
            lhs.assign(rhs);
            return lhs;
        }

        value result;
        switch (x.operator_)
        {
            case token_ids::plus_assign:        result = lhs + rhs; break;
            case token_ids::minus_assign:       result = lhs - rhs; break;
            case token_ids::times_assign:       result = lhs * rhs; break;
            case token_ids::divide_assign:      result = lhs / rhs; break;
            case token_ids::mod_assign:         result = lhs % rhs; break;
            case token_ids::bit_and_assign:     result = lhs & rhs; break;
            case token_ids::bit_xor_assign:     result = lhs ^ rhs; break;
            case token_ids::bit_or_assign:      result = lhs | rhs; break;
            case token_ids::shift_left_assign:  result = lhs << rhs; break;
            case token_ids::shift_right_assign: result = lhs >> rhs; break;
            default: BOOST_ASSERT(0);           return val();
        }

        lhs.assign(result);
        return lhs;
    }

    bool compiler::operator()(ast::variable_declaration const& x)
    {
        if (locals.find(x.lhs.name) != locals.end())
        {
            error_handler(x.lhs.id, "Duplicate variable: " + x.lhs.name);
            return false;
        }

        value init;
        std::string const& name = x.lhs.name;

        if (x.rhs) // if there's an RHS initializer
        {
            init = (*this)(*x.rhs);
            if (!init.is_valid()) // don't add the variable if the RHS fails
                return false;
        }

        value var_ = var(name.c_str());
        if (init.is_valid())
            var_.assign(init);

        // Remember this binding.
        locals[name] = var_;
        return true;
    }

    struct compiler::statement_compiler : compiler
    {
        typedef bool result_type;
    };

    compiler::statement_compiler& compiler::as_statement()
    {
        return *static_cast<statement_compiler*>(this);
    }

    bool compiler::operator()(ast::statement const& x)
    {
        if (boost::get<ast::nil>(&x) != 0) // empty statement
            return true;
        return boost::apply_visitor(as_statement(), x);
    }

    bool compiler::operator()(ast::statement_list const& x)
    {
        BOOST_FOREACH(ast::statement const& s, x)
        {
            if (!(*this)(s))
                return false;
        }
        return true;
    }

    bool compiler::operator()(ast::if_statement const& x)
    {
        value condition = (*this)(x.condition);
        if (!condition.is_valid())
            return false;

        function f = get_current_function();

        // Create blocks for the then and else cases.  Insert the 'then' block at the
        // end of the function.
        basic_block then_block = make_basic_block("if.then", f);
        basic_block else_block;
        basic_block exit_block;

        if (x.else_)
        {
            else_block = make_basic_block("if.else");
            conditional_branch(condition, then_block, else_block);
        }
        else
        {
            exit_block = make_basic_block("if.end");
            conditional_branch(condition, then_block, exit_block);
        }

        // Emit then value.
        set_insert_point(then_block);
        if (!(*this)(x.then))
            return false;
        if (!then_block.has_terminator())
        {
            if (!exit_block.is_valid())
                exit_block = make_basic_block("if.end");
            branch(exit_block);
        }
        // Codegen of 'then' can change the current block, update then_block
        then_block = get_insert_block();

        if (x.else_)
        {
            // Emit else block.
            f.add(else_block);
            set_insert_point(else_block);
            if (!(*this)(*x.else_))
                return false;
            if (!else_block.has_terminator())
            {
                if (!exit_block.is_valid())
                    exit_block = make_basic_block("if.end");
                branch(exit_block);
            }
            // Codegen of 'else' can change the current block, update else_block
            else_block = get_insert_block();
        }

        if (exit_block.is_valid())
        {
            // Emit exit block
            f.add(exit_block);
            set_insert_point(exit_block);
        }
        return true;
    }

    bool compiler::operator()(ast::while_statement const& x)
    {
        function f = get_current_function();

        basic_block cond_block = make_basic_block("while.cond", f);
        basic_block body_block = make_basic_block("while.body");
        basic_block exit_block = make_basic_block("while.end");

        branch(cond_block);
        set_insert_point(cond_block);
        value condition = (*this)(x.condition);
        if (!condition.is_valid())
            return false;
        conditional_branch(condition, body_block, exit_block);
        f.add(body_block);
        set_insert_point(body_block);

        if (!(*this)(x.body))
            return false;

        if (!body_block.has_terminator())
            branch(cond_block); // loop back

        // Emit exit block
        f.add(exit_block);
        set_insert_point(exit_block);

        return true;
    }

    bool compiler::operator()(ast::return_statement const& x)
    {
        if (void_return)
        {
            if (x.expr)
            {
                error_handler(
                    x.id, "'void' function returning a value: ");
                return false;
            }
        }
        else
        {
            if (!x.expr)
            {
                error_handler(
                    x.id, current_function_name
                    + " function must return a value: ");
                return false;
            }
        }

        if (x.expr)
        {
            value return_val = (*this)(*x.expr);
            if (!return_val.is_valid())
                return false;
            return_var.assign(return_val);
        }

        branch(return_block);
        return true;
    }

    function compiler::function_decl(ast::function const& x)
    {
        void_return = x.return_type == "void";
        current_function_name = x.function_name.name;

        function f =
            declare_function(
                void_return
              , current_function_name
              , x.args.size());

        // If function conflicted, the function already exixts. If it has a
        // body, don't allow redefinition or reextern.
        if (f.name() != current_function_name)
        {
            // Delete the one we just made and get the existing one.
            f.erase_from_parent();
            f = get_function(current_function_name);

            // If function already has a body, reject this.
            if (!f.empty())
            {
                error_handler(
                    x.function_name.id,
                    "Duplicate function: " + x.function_name.name);
                return function();
            }

            // If function took a different number of args, reject.
            if (f.arg_size() != x.args.size())
            {
                error_handler(
                    x.function_name.id,
                    "Redefinition of function with different # args: "
                        + x.function_name.name);
                return function();
            }

            // Set names for all arguments.
            function::arg_range rng = f.args();
            function::arg_range::const_iterator iter = rng.begin();
            BOOST_FOREACH(ast::identifier const& arg, x.args)
            {
                iter->name(arg.name);
                ++iter;
            }
        }
        return f;
    }

    void compiler::function_allocas(ast::function const& x, function f)
    {
        // Create variables for each argument and register the
        // argument in the symbol table so that references to it will succeed.
        function::arg_range rng = f.args();
        function::arg_range::const_iterator iter = rng.begin();
        BOOST_FOREACH(ast::identifier const& arg, x.args)
        {
            // Create an arg_ for this variable.
            value arg_ = var(arg.name);

            // Store the initial value into the arg_.
            arg_.assign(*iter);

            // Add arguments to variable symbol table.
            locals[arg.name] = arg_;
            ++iter;
        }

        if (!void_return)
        {
            // Create an alloca for the return value
            return_var = var("return.val");
        }
    }

    bool compiler::operator()(ast::function const& x)
    {
        ///////////////////////////////////////////////////////////////////////
        // the signature:
        function f = function_decl(x);
        if (!f.is_valid())
            return false;

        ///////////////////////////////////////////////////////////////////////
        // the body:
        if (x.body) // compile the body if this is not a prototype
        {
            // Create a new basic block to start insertion into.
            basic_block block = make_basic_block("entry", f);
            set_insert_point(block);

            function_allocas(x, f);
            return_block = make_basic_block("return");

            if (!(*this)(*x.body))
            {
                // Error reading body, remove function.
                f.erase_from_parent();
                return false;
            }

            basic_block last_block = f.last_block();

            // If the last block is unterminated, connect it to return_block
            if (!last_block.has_terminator())
            {
                set_insert_point(last_block);
                branch(return_block);
            }

            f.add(return_block);
            set_insert_point(return_block);

            if (void_return)
                return_();
            else
                return_(return_var);

            // Validate the generated code, checking for consistency.
            f.verify();

            // Optimize the function.
            optimize_function(f);
        }

        return true;
    }

    bool compiler::operator()(ast::function_list const& x)
    {
        BOOST_FOREACH(ast::function const& f, x)
        {
            locals.clear(); // clear the variables
            if (!(*this)(f))
                return false;
        }
        return true;
    }
}}