/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library
    Definition of the preprocessor context
    
    http://www.boost.org/

    Copyright (c) 2001-2005 Hartmut Kaiser. 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(CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)
#define CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED

#include <iterator>
#include <fstream>
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
#include <sstream>
#endif

#include <boost/wave/wave_config.hpp>
#include <boost/wave/cpp_exceptions.hpp>
#include <boost/wave/language_support.hpp>
#include <boost/wave/util/file_position.hpp>

///////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace wave {
namespace iteration_context_policies {

///////////////////////////////////////////////////////////////////////////////
//
//      The iteration_context_policies templates are policies for the 
//      boost::wave::iteration_context which allows to control, how a given input file 
//      is to be represented by a pair of iterators pointing to the begin and 
//      the end of the resulting input sequence.
//
///////////////////////////////////////////////////////////////////////////////

    ///////////////////////////////////////////////////////////////////////////
    //
    //  load_file_to_string
    //
    //      Loads a file into a string and returns the iterators pointing to 
    //      the beginning and the end of the loaded string.
    //
    ///////////////////////////////////////////////////////////////////////////
    struct load_file_to_string 
    {
        template <typename IterContextT>
        class inner 
        {
        public:
            template <typename PositionT>
            static 
            void init_iterators(IterContextT &iter_ctx, 
                PositionT const &act_pos)
            {
                typedef typename IterContextT::iterator_type iterator_type;
                
                std::ifstream instream(iter_ctx.filename.c_str());
                if (!instream.is_open()) {
                    BOOST_WAVE_THROW(preprocess_exception, bad_include_file, 
                        iter_ctx.filename.c_str(), act_pos);
                }
                instream.unsetf(std::ios::skipws);
                
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
            // this is known to be very slow for large files on some systems
                std::copy (istream_iterator<char>(instream),
                    istream_iterator<char>(), 
                    std::inserter(iter_ctx.instring, iter_ctx.instring.end()));
#else
                iter_ctx.instring = std::string(
                    std::istreambuf_iterator<char>(instream.rdbuf()),
                    std::istreambuf_iterator<char>());
#endif // defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)

                iter_ctx.first = iterator_type(iter_ctx.instring.begin(), 
                    iter_ctx.instring.end(), PositionT(iter_ctx.filename),
                    iter_ctx.language);
                iter_ctx.last = iterator_type();
            }

        private:
            std::string instring;
        };
    };
    
///////////////////////////////////////////////////////////////////////////////
//
//  load_file
//
//      The load_file policy opens a given file and returns the wrapped
//      istreambuf_iterators.
//
///////////////////////////////////////////////////////////////////////////////
    struct load_file 
    {
        template <typename IterContextT>
        class inner {

        public:
            ~inner() { if (instream.is_open()) instream.close(); }
            
            template <typename PositionT>
            static 
            void init_iterators(IterContextT &iter_ctx, 
                PositionT const &act_pos)
            {
                typedef typename IterContextT::iterator_type iterator_type;
                
                iter_ctx.instream.open(iter_ctx.filename.c_str());
                if (!iter_ctx.instream.is_open()) {
                    BOOST_WAVE_THROW(preprocess_exception, bad_include_file, 
                        iter_ctx.filename.c_str(), act_pos);
                }
                iter_ctx.instream.unsetf(std::ios::skipws);

                using boost::spirit::make_multi_pass;
                iter_ctx.first = iterator_type(
                    make_multi_pass(std::istreambuf_iterator<char>(
                        iter_ctx.instream.rdbuf())),
                    make_multi_pass(std::istreambuf_iterator<char>()),
                    PositionT(iter_ctx.filename), iter_ctx.language);
                iter_ctx.last = iterator_type();
            }

        private:
            std::ifstream instream;
        };
    };
    
}   // namespace iterattion_context_policies

///////////////////////////////////////////////////////////////////////////////
//  
template <typename IteratorT>
struct base_iteration_context 
{
public:
    base_iteration_context(
            BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0)   
    :   real_filename(fname), filename(fname), line(1), emitted_lines(1),
        if_block_depth(if_block_depth)
    {}
    base_iteration_context(IteratorT const &first_, IteratorT const &last_, 
            BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0)
    :   first(first_), last(last_), real_filename(fname), filename(fname), 
        line(1), emitted_lines(1), if_block_depth(if_block_depth)
    {}

// the actual input stream
    IteratorT first;            // actual input stream position 
    IteratorT last;             // end of input stream
    BOOST_WAVE_STRINGTYPE real_filename;  // real name of the current file
    BOOST_WAVE_STRINGTYPE filename;       // actual processed file
    unsigned int line;                    // line counter of underlying stream
    unsigned int emitted_lines;           // count of emitted newlines
    std::size_t if_block_depth; // depth of #if block recursion
};

///////////////////////////////////////////////////////////////////////////////
//  
template <
    typename IteratorT, 
    typename InputPolicyT = 
        iteration_context_policies::load_file_to_string 
>
struct iteration_context
:   public base_iteration_context<IteratorT>,
    public InputPolicyT::template 
        inner<iteration_context<IteratorT, InputPolicyT> >
{
    typedef IteratorT iterator_type;
    typedef typename IteratorT::token_type::position_type position_type;
    
    typedef iteration_context<IteratorT, InputPolicyT> self_type;
    
    iteration_context(BOOST_WAVE_STRINGTYPE const &fname, 
            position_type const &act_pos, 
            boost::wave::language_support language_) 
    :   base_iteration_context<IteratorT>(fname), 
        language(language_)
    {
        InputPolicyT::template inner<self_type>::init_iterators(*this, act_pos);
    }
    
    boost::wave::language_support language;
};

///////////////////////////////////////////////////////////////////////////////
}   // namespace wave
}   // namespace boost

#endif // !defined(CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)