EIC code displayed by LXR master/​include/​boost/​spirit/​home/​classic/​iterator/​impl/​file_iterator.ipp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-16 10:09:00

 /*=============================================================================
     Copyright (c) 2003 Giovanni Bajo
     Copyright (c) 2003 Martin Wille
     Copyright (c) 2003 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)
 =============================================================================*/
 
 #ifndef BOOST_SPIRIT_FILE_ITERATOR_IPP
 #define BOOST_SPIRIT_FILE_ITERATOR_IPP
 
 #ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS
 #  include <windows.h>
 #endif
 
 #include <cstdio>
 #include <boost/shared_ptr.hpp>
 
 #ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS
 #  include <boost/type_traits/remove_pointer.hpp>
 #endif
 
 #ifdef BOOST_SPIRIT_FILEITERATOR_POSIX
 #  include <sys/types.h> // open, stat, mmap, munmap
 #  include <sys/stat.h>  // stat
 #  include <fcntl.h>     // open
 #  include <unistd.h>    // stat, mmap, munmap
 #  include <sys/mman.h>  // mmap, mmunmap
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit {
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace fileiter_impl {
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  std_file_iterator
 //
 //  Base class that implements iteration through a file using standard C
 //  stream library (fopen and friends). This class and the following are
 //  the base components on which the iterator is built (through the
 //  iterator adaptor library).
 //
 //  The opened file stream (FILE) is held with a shared_ptr<>, whose
 //  custom deleter invokes fcose(). This makes the syntax of the class
 //  very easy, especially everything related to copying.
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename CharT>
 class std_file_iterator
 {
 public:
     typedef CharT value_type;
 
     std_file_iterator()
     {}
 
     explicit std_file_iterator(std::string const& fileName)
     {
         using namespace std;
         FILE* f = fopen(fileName.c_str(), "rb");
 
         // If the file was opened, store it into
         //  the smart pointer.
         if (f)
         {
             m_file.reset(f, fclose);
             m_pos = 0;
             m_eof = false;
             update_char();
         }
     }
 
     std_file_iterator(const std_file_iterator& iter)
     { *this = iter; }
 
     std_file_iterator& operator=(const std_file_iterator& iter)
     {
         m_file = iter.m_file;
         m_curChar = iter.m_curChar;
         m_eof = iter.m_eof;
         m_pos = iter.m_pos;
 
         return *this;
     }
 
     // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context
     //  for shared_ptr to evaluate correctly
     operator bool() const
     { return m_file ? true : false; }
 
     bool operator==(const std_file_iterator& iter) const
     {
         return (m_file == iter.m_file) && (m_eof == iter.m_eof) &&
             (m_pos == iter.m_pos);
     }
 
     const CharT& get_cur_char(void) const
     {
         return m_curChar;
     }
 
     void prev_char(void)
     {
         m_pos -= sizeof(CharT);
         update_char();
     }
 
     void next_char(void)
     {
         m_pos += sizeof(CharT);
         update_char();
     }
 
     void seek_end(void)
     {
         using namespace std;
         fseek(m_file.get(), 0, SEEK_END);
         m_pos = ftell(m_file.get()) / sizeof(CharT);
         m_eof = true;
     }
 
     void advance(std::ptrdiff_t n)
     {
         m_pos += static_cast<long>(n) * sizeof(CharT);
         update_char();
     }
 
     std::ptrdiff_t distance(const std_file_iterator& iter) const
     {
         return (std::ptrdiff_t)(m_pos - iter.m_pos) / sizeof(CharT);
     }
 
 private:
     boost::shared_ptr<std::FILE> m_file;
     long m_pos;
     CharT m_curChar;
     bool m_eof;
 
     void update_char(void)
     {
         using namespace std;
         if (ftell(m_file.get()) != m_pos)
             fseek(m_file.get(), m_pos, SEEK_SET);
 
         m_eof = (fread(&m_curChar, sizeof(CharT), 1, m_file.get()) < 1);
     }
 };
 
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 //  mmap_file_iterator
 //
 //  File iterator for memory mapped files, for now implemented on Windows and
 //  POSIX  platforms. This class has the same interface of std_file_iterator,
 //  and can be used in its place (in fact, it's the default for Windows and
 //  POSIX).
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 // mmap_file_iterator, Windows version
 #ifdef BOOST_SPIRIT_FILEITERATOR_WINDOWS
 template <typename CharT>
 class mmap_file_iterator
 {
 public:
     typedef CharT value_type;
 
     mmap_file_iterator()
       : m_filesize(0), m_curChar(0)
     {}
 
     explicit mmap_file_iterator(std::string const& fileName)
       : m_filesize(0), m_curChar(0)
     {
         HANDLE hFile = ::CreateFileA(
             fileName.c_str(),
             GENERIC_READ,
             FILE_SHARE_READ,
             NULL,
             OPEN_EXISTING,
             FILE_FLAG_SEQUENTIAL_SCAN,
             NULL
         );
 
         if (hFile == INVALID_HANDLE_VALUE)
             return;
 
         // Store the size of the file, it's used to construct
         //  the end iterator
         m_filesize = ::GetFileSize(hFile, NULL);
 
         HANDLE hMap = ::CreateFileMapping(
             hFile,
             NULL,
             PAGE_READONLY,
             0, 0,
             NULL
         );
 
         if (hMap == NULL)
         {
             ::CloseHandle(hFile);
             return;
         }
 
         LPVOID pMem = ::MapViewOfFile(
             hMap,
             FILE_MAP_READ,
             0, 0, 0
         );
 
         if (pMem == NULL)
         {
             ::CloseHandle(hMap);
             ::CloseHandle(hFile);
             return;
         }
 
         // We hold both the file handle and the memory pointer.
         // We can close the hMap handle now because Windows holds internally
         //  a reference to it since there is a view mapped.
         ::CloseHandle(hMap);
 
         // It seems like we can close the file handle as well (because
         //  a reference is hold by the filemap object).
         ::CloseHandle(hFile);
 
         // Store the handles inside the shared_ptr (with the custom destructors)
         m_mem.reset(static_cast<CharT*>(pMem), ::UnmapViewOfFile);
 
         // Start of the file
         m_curChar = m_mem.get();
     }
 
     mmap_file_iterator(const mmap_file_iterator& iter)
     { *this = iter; }
 
     mmap_file_iterator& operator=(const mmap_file_iterator& iter)
     {
         m_curChar = iter.m_curChar;
         m_mem = iter.m_mem;
         m_filesize = iter.m_filesize;
 
         return *this;
     }
 
     // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context
     //  for shared_ptr to evaluate correctly
     operator bool() const
     { return m_mem ? true : false; }
 
     bool operator==(const mmap_file_iterator& iter) const
     { return m_curChar == iter.m_curChar; }
 
     const CharT& get_cur_char(void) const
     { return *m_curChar; }
 
     void next_char(void)
     { m_curChar++; }
 
     void prev_char(void)
     { m_curChar--; }
 
     void advance(std::ptrdiff_t n)
     { m_curChar += n; }
 
     std::ptrdiff_t distance(const mmap_file_iterator& iter) const
     { return m_curChar - iter.m_curChar; }
 
     void seek_end(void)
     {
         m_curChar = m_mem.get() +
             (m_filesize / sizeof(CharT));
     }
 
 private:
     typedef boost::remove_pointer<HANDLE>::type handle_t;
 
     boost::shared_ptr<CharT> m_mem;
     std::size_t m_filesize;
     CharT* m_curChar;
 };
 
 #endif // BOOST_SPIRIT_FILEITERATOR_WINDOWS
 
 ///////////////////////////////////////////////////////////////////////////////
 // mmap_file_iterator, POSIX version
 #ifdef BOOST_SPIRIT_FILEITERATOR_POSIX
 template <typename CharT>
 class mmap_file_iterator
 {
 private:
     struct mapping
     {
         mapping(void *p, off_t len)
             : data(p)
             , size(len)
         { }
 
         CharT const *begin() const
         {
             return static_cast<CharT *>(data);
         }
 
         CharT const *end() const
         {
             return static_cast<CharT *>(data) + size/sizeof(CharT);
         }
 
         ~mapping()
         {
             munmap(static_cast<char*>(data), size);
         }
 
     private:
         void *data;
         off_t size;
     };
 
 public:
     typedef CharT value_type;
 
     mmap_file_iterator()
       : m_curChar(0)
     {}
 
     explicit mmap_file_iterator(std::string const& file_name)
       : m_curChar(0)
     {
         // open the file
        int fd = open(file_name.c_str(),
 #ifdef O_NOCTTY
             O_NOCTTY | // if stdin was closed then opening a file
                        // would cause the file to become the controlling
                        // terminal if the filename refers to a tty. Setting
                        // O_NOCTTY inhibits this.
 #endif
             O_RDONLY);
 
         if (fd == -1)
             return;
 
         // call fstat to find get information about the file just
         // opened (size and file type)
         struct stat stat_buf;
         if ((fstat(fd, &stat_buf) != 0) || !S_ISREG(stat_buf.st_mode))
         {   // if fstat returns an error or if the file isn't a
             // regular file we give up.
             close(fd);
             return;
         }
 
         // perform the actual mapping
         void *p = mmap(0, stat_buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
         // it is safe to close() here. POSIX requires that the OS keeps a
         // second handle to the file while the file is mmapped.
         close(fd);
 
         if (p == MAP_FAILED)
             return;
 
         mapping *m = 0;
         try
         {
             m = new mapping(p, stat_buf.st_size);
         }
         catch(...)
         {
             munmap(static_cast<char*>(p), stat_buf.st_size);
             throw;
         }
 
         m_mem.reset(m);
 
         // Start of the file
         m_curChar = m_mem->begin();
     }
 
     mmap_file_iterator(const mmap_file_iterator& iter)
     { *this = iter; }
 
     mmap_file_iterator& operator=(const mmap_file_iterator& iter)
     {
         m_curChar = iter.m_curChar;
         m_mem = iter.m_mem;
 
         return *this;
     }
 
     // Nasty bug in Comeau up to 4.3.0.1, we need explicit boolean context
     //  for shared_ptr to evaluate correctly
     operator bool() const
     { return m_mem ? true : false; }
 
     bool operator==(const mmap_file_iterator& iter) const
     { return m_curChar == iter.m_curChar; }
 
     const CharT& get_cur_char(void) const
     { return *m_curChar; }
 
     void next_char(void)
     { m_curChar++; }
 
     void prev_char(void)
     { m_curChar--; }
 
     void advance(signed long n)
     { m_curChar += n; }
 
     long distance(const mmap_file_iterator& iter) const
     { return m_curChar - iter.m_curChar; }
 
     void seek_end(void)
     {
         m_curChar = m_mem->end();
     }
 
 private:
 
     boost::shared_ptr<mapping> m_mem;
     CharT const* m_curChar;
 };
 
 #endif // BOOST_SPIRIT_FILEITERATOR_POSIX
 
 ///////////////////////////////////////////////////////////////////////////////
 } /* namespace boost::spirit::fileiter_impl */
 
 template <typename CharT, typename BaseIteratorT>
 file_iterator<CharT,BaseIteratorT>
 file_iterator<CharT,BaseIteratorT>::make_end(void)
 {
     file_iterator iter(*this);
     iter.base_reference().seek_end();
     return iter;
 }
 
 template <typename CharT, typename BaseIteratorT>
 file_iterator<CharT,BaseIteratorT>&
 file_iterator<CharT,BaseIteratorT>::operator=(const base_t& iter)
 {
     base_t::operator=(iter);
     return *this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 
 }} /* namespace boost::spirit */
 
 
 #endif /* BOOST_SPIRIT_FILE_ITERATOR_IPP */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team