diff -r 000000000000 -r e4d67989cc36 ossrv_pub/boost_apis/boost/wave/cpp_iteration_context.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ossrv_pub/boost_apis/boost/wave/cpp_iteration_context.hpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,205 @@ +/*============================================================================= + Boost.Wave: A Standard compliant C++ preprocessor library + Definition of the preprocessor context + + http://www.boost.org/ + + Copyright (c) 2001-2007 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 +#include +#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) +#include +#endif + +#include +#include +#include +#include + +// this must occur after all of the includes and before any code appears +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_PREFIX +#endif + +/////////////////////////////////////////////////////////////////////////////// +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 + class inner + { + public: + template + 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(instream), + istream_iterator(), + std::inserter(iter_ctx.instring, iter_ctx.instring.end())); +#else + iter_ctx.instring = std::string( + std::istreambuf_iterator(instream.rdbuf()), + std::istreambuf_iterator()); +#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 + class inner { + + public: + ~inner() { if (instream.is_open()) instream.close(); } + + template + 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( + iter_ctx.instream.rdbuf())), + make_multi_pass(std::istreambuf_iterator()), + PositionT(iter_ctx.filename), iter_ctx.language); + iter_ctx.last = iterator_type(); + } + + private: + std::ifstream instream; + }; + }; + +} // namespace iteration_context_policies + +/////////////////////////////////////////////////////////////////////////////// +// +template +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, + public InputPolicyT::template + inner > +{ + typedef IteratorT iterator_type; + typedef typename IteratorT::token_type::position_type position_type; + + typedef iteration_context self_type; + + iteration_context(BOOST_WAVE_STRINGTYPE const &fname, + position_type const &act_pos, + boost::wave::language_support language_) + : base_iteration_context(fname), + language(language_) + { + InputPolicyT::template inner::init_iterators(*this, act_pos); + } + + boost::wave::language_support language; +}; + +/////////////////////////////////////////////////////////////////////////////// +} // namespace wave +} // namespace boost + +// the suffix header occurs after all of the code +#ifdef BOOST_HAS_ABI_HEADERS +#include BOOST_ABI_SUFFIX +#endif + +#endif // !defined(CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)