requirements.hpp

Go to the documentation of this file.

/*=============================================================================
    Adapted from boost spirit mini_c example.
 
    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)
=============================================================================*/
#if !defined(REQUIREMENTS_HPP)
#define REQUIREMENTS_HPP
 
#include "ast.hpp"
#include "error_handler.hpp"
#include <set>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_function.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
 
namespace client { namespace code_gen
{
    struct requirements
    {
        typedef bool result_type;
 
        template <typename ErrorHandler>
        requirements(ErrorHandler& error_handler_)
        {
            namespace phx = boost::phoenix;
            using boost::phoenix::function;
 
            error_handler = function<ErrorHandler>(error_handler_)
                (std::string("Error! "),
                 phx::arg_names::_2,
                 phx::cref(error_handler_.iters)[phx::arg_names::_1]);
        }
 
        bool operator()(ast::nil) { BOOST_ASSERT(0); return false; }
        bool operator()(unsigned int /*x*/) { return true; }
        bool operator()(double /*x*/) { return true; }
        bool operator()(bool /*x*/) { return true; }
        bool operator()(ast::quoted_string const & /*x*/) { return true; }
 
        bool operator()(ast::operation const& x) {
            if (!boost::apply_visitor(*this, x.operand_))
                return false;
            return true;
        }
 
        bool operator()(ast::unary const& x) {
            if (!boost::apply_visitor(*this, x.operand_))
                return false;
            return true;
        }
 
        bool operator()(ast::identifier const& x) {
            variables_.insert(x.name);
 
            return true;
        }
 
        bool operator()(ast::function_call const& x) {
            functions_.insert(x.function_name.name);
 
            for(ast::function_call_argument const& arg: x.args) {
                if (!boost::apply_visitor(*this, arg))
                    return false;
                //if (!(*this)(arg))
                    //return false;
            }
            return true;
        }
 
        bool operator()(ast::expression const& x) {
 
            if (!boost::apply_visitor(*this, x.first))
                return false;
 
            for(ast::operation const& oper: x.rest) {
                if (!(*this)(oper))
                    return false;
        }
 
        return true;
    }
 
    std::set<std::string> variables() { return variables_; }
    std::set<std::string> functions() { return functions_; }
 
    private:
 
        boost::function<
            void(int tag, std::string const& what)>
        error_handler;
 
        std::set<std::string> variables_;
        std::set<std::string> functions_;
    };
}}
 
#endif