text: /*=============================================================================
      Boost.Wave: A Standard compliant C++ preprocessor library
      Definition of the preprocessor context
  
      http://www.boost.org/
  
      Copyright (c) 2001-2012 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>
  // #include <boost/spirit/include/iterator/classic_multi_pass.hpp> // make_multi_pass
  
  // 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 <typename IterContextT>
          class inner
          {
          public:
              template <typename PositionT>
              static void init_iterators(IterContextT &iter_ctx,
                  PositionT const &act_pos, language_support language)
              {
                  typedef typename IterContextT::iterator_type iterator_type;
  
                  // read in the file
                  std::ifstream instream(iter_ctx.filename.c_str());
                  if (!instream.is_open()) {
                      BOOST_WAVE_THROW_CTX(iter_ctx.ctx, preprocess_exception,
                          bad_include_file, iter_ctx.filename.c_str(), act_pos);
                      return;
                  }
                  instream.unsetf(std::ios::skipws);
  
                  iter_ctx.instring.assign(
                      std::istreambuf_iterator<char>(instream.rdbuf()),
                      std::istreambuf_iterator<char>());
  
                  iter_ctx.first = iterator_type(
                      iter_ctx.instring.begin(), iter_ctx.instring.end(),
                      PositionT(iter_ctx.filename), language);
                  iter_ctx.last = iterator_type();
              }
  
          private:
              std::string instring;
          };
      };
  
  }   // namespace iteration_context_policies
  
  ///////////////////////////////////////////////////////////////////////////////
  //  Base class for iteration contexts
  template <typename ContextT, typename IteratorT>
  struct base_iteration_context
  {
      enum file_type
      {
          // this iteration context handles ...
          main_file,      // ... the main preprocessed file
          system_header,  // ... a header file included used #include  <>
          user_header     // ... a header file included using #include ""
      };
  
      base_iteration_context(ContextT& ctx_,
              BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0)
      :   real_filename(fname), real_relative_filename(fname), filename(fname),
          line(1), emitted_lines(0), if_block_depth(if_block_depth), ctx(ctx_),
          type(main_file)
      {}
      base_iteration_context(ContextT& ctx_,
              IteratorT const &first_, IteratorT const &last_,
              BOOST_WAVE_STRINGTYPE const &fname, std::size_t if_block_depth = 0,
              file_type type_ = main_file)
      :   first(first_), last(last_), real_filename(fname),
          real_relative_filename(fname), filename(fname),
          line(1), emitted_lines(0), if_block_depth(if_block_depth), ctx(ctx_),
          type(type_)
      {}
  
  // 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 real_relative_filename;  // real relative name of the current file
      BOOST_WAVE_STRINGTYPE filename;       // actual processed file
      std::size_t line;                     // line counter of underlying stream
      std::size_t emitted_lines;            // count of emitted newlines
      std::size_t if_block_depth; // depth of #if block recursion
      ContextT& ctx;              // corresponding context<> object
      file_type type;             // the type of the handled file
  };
  
  ///////////////////////////////////////////////////////////////////////////////
  //
  template <
      typename ContextT, typename IteratorT,
      typename InputPolicyT = typename ContextT::input_policy_type
  >
  struct iteration_context
  :   public base_iteration_context<ContextT, IteratorT>,
      public InputPolicyT::template
          inner<iteration_context<ContextT, IteratorT, InputPolicyT> >
  {
      typedef IteratorT iterator_type;
      typedef typename IteratorT::token_type::position_type position_type;
  
      typedef base_iteration_context<ContextT, IteratorT> base_type;
      typedef iteration_context<ContextT, IteratorT, InputPolicyT> self_type;
  
      iteration_context(ContextT& ctx, BOOST_WAVE_STRINGTYPE const &fname,
              position_type const &act_pos,
              boost::wave::language_support language_,
              typename base_type::file_type type = base_type::main_file)
      :   base_iteration_context<ContextT, IteratorT>(ctx, fname, type)
      {
          InputPolicyT::template inner<self_type>::init_iterators(
              *this, act_pos, 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)
  