ceph/src/boost/boost/wave/cpp_iteration_context.hpp

   1 /*=============================================================================
   2     Boost.Wave: A Standard compliant C++ preprocessor library
   3     Definition of the preprocessor context
   4
   5     http://www.boost.org/
   6
   7     Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
   8     Software License, Version 1.0. (See accompanying file
   9     LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  10 =============================================================================*/
  11
  12 #if !defined(BOOST_CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)
  13 #define BOOST_CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED
  14
  15 #include <iterator>
  16 #include <boost/filesystem/fstream.hpp>
  17 #if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
  18 #include <sstream>
  19 #endif
  20
  21 #include <boost/wave/wave_config.hpp>
  22 #include <boost/wave/cpp_exceptions.hpp>
  23 #include <boost/wave/language_support.hpp>
  24 #include <boost/wave/util/file_position.hpp>
  25 // #include <boost/spirit/include/iterator/classic_multi_pass.hpp> // make_multi_pass
  26
  27 // this must occur after all of the includes and before any code appears
  28 #ifdef BOOST_HAS_ABI_HEADERS
  29 #include BOOST_ABI_PREFIX
  30 #endif
  31
  32 ///////////////////////////////////////////////////////////////////////////////
  33 namespace boost {
  34 namespace wave {
  35 namespace iteration_context_policies {
  36
  37 ///////////////////////////////////////////////////////////////////////////////
  38 //
  39 //      The iteration_context_policies templates are policies for the
  40 //      boost::wave::iteration_context which allows to control, how a given
  41 //      input file is to be represented by a pair of iterators pointing to the
  42 //      begin and the end of the resulting input sequence.
  43 //
  44 ///////////////////////////////////////////////////////////////////////////////
  45
  46     ///////////////////////////////////////////////////////////////////////////
  47     //
  48     //  load_file_to_string
  49     //
  50     //      Loads a file into a string and returns the iterators pointing to
  51     //      the beginning and the end of the loaded string.
  52     //
  53     ///////////////////////////////////////////////////////////////////////////
  54     struct load_file_to_string
  55     {
  56         template <typename IterContextT>
  57         class inner
  58         {
  59         public:
  60             template <typename PositionT>
  61             static void init_iterators(IterContextT &iter_ctx,
  62                 PositionT const &act_pos, language_support language)
  63             {
  64                 typedef typename IterContextT::iterator_type iterator_type;
  65
  66                 // read in the file
  67                 boost::filesystem::ifstream instream(iter_ctx.filename.c_str());
  68                 if (!instream.is_open()) {
  69                     BOOST_WAVE_THROW_CTX(iter_ctx.ctx, preprocess_exception,
  70                         bad_include_file, iter_ctx.filename.c_str(), act_pos);
  71                     return;
  72                 }
  73                 instream.unsetf(std::ios::skipws);
  74
  75                 iter_ctx.instring.assign(
  76                     std::istreambuf_iterator<char>(instream.rdbuf()),
  77                     std::istreambuf_iterator<char>());
  78
  79                 iter_ctx.first = iterator_type(
  80                     iter_ctx.instring.begin(), iter_ctx.instring.end(),
  81                     PositionT(iter_ctx.filename), language);
  82                 iter_ctx.last = iterator_type();
  83             }
  84
  85         private:
  86             std::string instring;
  87         };
  88     };
  89
  90 }   // namespace iteration_context_policies
  91
  92 ///////////////////////////////////////////////////////////////////////////////
  93 //  Base class for iteration contexts
  94 template <typename ContextT, typename IteratorT>
  95 struct base_iteration_context
  96 {
  97     enum file_type
  98     {
  99         // this iteration context handles ...
 100         main_file,      // ... the main preprocessed file
 101         system_header,  // ... a header file included used #include  <>
 102         user_header     // ... a header file included using #include ""
 103     };
 104
 105     base_iteration_context(ContextT& ctx_,
 106             BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0)
 107     :   real_filename(fname), real_relative_filename(fname), filename(fname),
 108         line(1), emitted_lines(0), if_block_depth(if_block_depth), ctx(ctx_),
 109         type(main_file)
 110     {}
 111     base_iteration_context(ContextT& ctx_,
 112             IteratorT const &first_, IteratorT const &last_,
 113             BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0,
 114             file_type type_ = main_file)
 115     :   first(first_), last(last_), real_filename(fname),
 116         real_relative_filename(fname), filename(fname),
 117         line(1), emitted_lines(0), if_block_depth(if_block_depth), ctx(ctx_),
 118         type(type_)
 119     {}
 120
 121     // the actual input stream
 122     IteratorT first;            // actual input stream position
 123     IteratorT last;             // end of input stream
 124     BOOST_WAVE_STRINGTYPE real_filename;  // real name of the current file
 125     BOOST_WAVE_STRINGTYPE real_relative_filename;  // real relative name of the current file
 126     BOOST_WAVE_STRINGTYPE filename;       // actual processed file
 127     std::size_t line;                     // line counter of underlying stream
 128     std::size_t emitted_lines;            // count of emitted newlines
 129     std::size_t if_block_depth; // depth of #if block recursion
 130     ContextT& ctx;              // corresponding context<> object
 131     file_type type;             // the type of the handled file
 132 };
 133
 134 ///////////////////////////////////////////////////////////////////////////////
 135 //
 136 template <
 137     typename ContextT, typename IteratorT,
 138     typename InputPolicyT = typename ContextT::input_policy_type
 139 >
 140 struct iteration_context
 141 :   public base_iteration_context<ContextT, IteratorT>,
 142     public InputPolicyT::template
 143         inner<iteration_context<ContextT, IteratorT, InputPolicyT> >
 144 {
 145     typedef IteratorT iterator_type;
 146     typedef typename IteratorT::token_type::position_type position_type;
 147
 148     typedef base_iteration_context<ContextT, IteratorT> base_type;
 149     typedef iteration_context<ContextT, IteratorT, InputPolicyT> self_type;
 150
 151     iteration_context(ContextT& ctx, BOOST_WAVE_STRINGTYPE const &fname,
 152             position_type const &act_pos,
 153             boost::wave::language_support language_,
 154             typename base_type::file_type type = base_type::main_file)
 155     :   base_iteration_context<ContextT, IteratorT>(ctx, fname, type)
 156     {
 157         InputPolicyT::template inner<self_type>::init_iterators(
 158             *this, act_pos, language_);
 159     }
 160 };
 161
 162 ///////////////////////////////////////////////////////////////////////////////
 163 }   // namespace wave
 164 }   // namespace boost
 165
 166 // the suffix header occurs after all of the code
 167 #ifdef BOOST_HAS_ABI_HEADERS
 168 #include BOOST_ABI_SUFFIX
 169 #endif
 170
 171 #endif // !defined(BOOST_CPP_ITERATION_CONTEXT_HPP_00312288_9DDB_4668_AFE5_25D3994FD095_INCLUDED)