/*=============================================================================
Wave: A Standard compliant C++ preprocessor
Definition of the preprocessor context
Copyright (c) 2001-2004 Hartmut Kaiser
http://spirit.sourceforge.net/
Use, modification and distribution is subject to 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)
See Copyright.txt for full acknowledgements.
=============================================================================*/
#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>
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
#include <sstream>
#endif
#include "wave/cpp_exceptions.hpp"
#include "wave/language_support.hpp"
#include "wave/util/file_position.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace wave {
namespace iteration_context_policies {
///////////////////////////////////////////////////////////////////////////////
//
// The iteration_context_policies templates are policies for the
// 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_t iterator_t;
std::ifstream instream(iter_ctx.filename.c_str());
if (!instream.is_open()) {
CPP_THROW(preprocess_exception, bad_include_file,
iter_ctx.filename, 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_t(iter_ctx.instring.begin(),
iter_ctx.instring.end(), PositionT(iter_ctx.filename),
iter_ctx.language);
iter_ctx.last = iterator_t();
}
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_t iterator_t;
iter_ctx.instream.open(iter_ctx.filename.c_str());
if (!iter_ctx.instream.is_open()) {
CPP_THROW(preprocess_exception, bad_include_file,
iter_ctx.filename, act_pos);
}
iter_ctx.instream.unsetf(std::ios::skipws);
using boost::spirit::make_multi_pass;
iter_ctx.first = iterator_t(
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_t();
}
private:
std::ifstream instream;
};
};
} // namespace iterattion_context_policies
///////////////////////////////////////////////////////////////////////////////
//
template <typename IteratorT>
struct base_iteration_context {
public:
base_iteration_context(WAVE_STRINGTYPE const &fname)
: real_filename(fname), filename(fname), line(1), emitted_lines(1)
{}
base_iteration_context(IteratorT const &first_, IteratorT const &last_,
WAVE_STRINGTYPE const &fname)
: first(first_), last(last_), real_filename(fname), filename(fname),
line(1), emitted_lines(1)
{}
// the actual input stream
IteratorT first; // actual input stream position
IteratorT last; // end of input stream
WAVE_STRINGTYPE real_filename; // real name of the current file
WAVE_STRINGTYPE filename; // actual processed file
int line; // line counter of underlying stream
int emitted_lines; // count of emitted newlines
};
///////////////////////////////////////////////////////////////////////////////
//
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_t;
typedef typename IteratorT::token_t::position_t position_t;
typedef iteration_context<IteratorT, InputPolicyT> self_t;
iteration_context(WAVE_STRINGTYPE const &fname, position_t const &act_pos,
wave::language_support language_)
: base_iteration_context<IteratorT>(fname),
language(language_)
{
InputPolicyT::template inner<self_t>::init_iterators(*this, act_pos);
}
wave::language_support language;
};
///////////////////////////////////////////////////////////////////////////////
} // namespace wave
#endif // !defined(CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)