185 lines
4.2 KiB
C++
185 lines
4.2 KiB
C++
/*
|
|
* This file is part of libgim.
|
|
*
|
|
* libgim is free software: you can redistribute it and/or modify it under the
|
|
* terms of the GNU General Public License as published by the Free Software
|
|
* Foundation, either version 3 of the License, or (at your option) any later
|
|
* version.
|
|
*
|
|
* libgim is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with libgim. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Copyright 2010-2012 Danny Robson <danny@blubinc.net>
|
|
*/
|
|
|
|
#include "io.hpp"
|
|
|
|
#include "debug.hpp"
|
|
#include "except.hpp"
|
|
|
|
#include <cstdio>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
|
|
using namespace std;
|
|
using namespace util;
|
|
|
|
//----------------------------------------------------------------------------
|
|
uint8_t *
|
|
util::slurp (const boost::filesystem::path& path) {
|
|
fd_ref fd(open (path.string ().c_str (), O_RDONLY)); // | O_CLOEXEC));
|
|
|
|
// Calculate the total file size
|
|
off_t size = lseek (fd, 0, SEEK_END);
|
|
if (size == (off_t)-1)
|
|
throw errno_error();
|
|
|
|
if (lseek (fd, 0, SEEK_SET) == (off_t)-1)
|
|
throw errno_error ();
|
|
|
|
// Allocate a buffer, and keep reading until it's full. We provide a null
|
|
// padding at the tail as a 'just in case' measure for string manipulation.
|
|
unique_ptr <uint8_t[]> buffer (new uint8_t[size + 1]);
|
|
buffer.get()[size] = '\0';
|
|
|
|
check_hard (size >= 0);
|
|
size_t remaining = (size_t)size;
|
|
uint8_t *cursor = buffer.get();
|
|
|
|
while (remaining) {
|
|
ssize_t consumed = read (fd, cursor, remaining);
|
|
if (consumed == -1)
|
|
throw errno_error();
|
|
check_hard ( consumed >= 0);
|
|
check_hard ((size_t)consumed <= remaining);
|
|
|
|
remaining -= (size_t)consumed;
|
|
cursor += consumed;
|
|
}
|
|
|
|
return buffer.release();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
fd_ref::fd_ref (int _fd):
|
|
fd (_fd)
|
|
{
|
|
if (fd < 0)
|
|
throw invalid_argument ("invalid file descriptor");
|
|
}
|
|
|
|
|
|
fd_ref::~fd_ref () {
|
|
check (fd >= 0);
|
|
close (fd);
|
|
}
|
|
|
|
|
|
fd_ref::operator int (void) const
|
|
{ return fd; }
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
indenter::overflow (int ch) {
|
|
if (m_line_start && ch != '\n')
|
|
m_dest->sputn (m_indent.data (), sign_cast<std::streamsize> (m_indent.size ()));
|
|
|
|
m_line_start = ch == '\n';
|
|
return m_dest->sputc (ch);
|
|
}
|
|
|
|
|
|
indenter::indenter (std::streambuf* _dest, size_t _indent)
|
|
: m_dest (_dest)
|
|
, m_line_start (true)
|
|
, m_indent (_indent, ' ')
|
|
, m_owner (NULL)
|
|
{ ; }
|
|
|
|
|
|
indenter::indenter (std::ostream& _dest, size_t _indent)
|
|
: m_dest (_dest.rdbuf())
|
|
, m_line_start (true)
|
|
, m_indent (_indent, ' ')
|
|
, m_owner (&_dest)
|
|
{
|
|
m_owner->rdbuf (this);
|
|
}
|
|
|
|
|
|
indenter::~indenter ()
|
|
{
|
|
if (m_owner != NULL)
|
|
m_owner->rdbuf (m_dest);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
#if defined(HAVE_MMAP)
|
|
#include <sys/mman.h>
|
|
|
|
|
|
mapped_file::mapped_file (const char *_path):
|
|
m_fd (open (_path, O_RDONLY))
|
|
{ load_fd (); }
|
|
|
|
|
|
mapped_file::mapped_file (const std::string &_path):
|
|
m_fd (open (_path.c_str (), O_RDONLY))
|
|
{ load_fd (); }
|
|
|
|
|
|
mapped_file::mapped_file (const boost::filesystem::path &_path):
|
|
m_fd (open (_path.native ().c_str (), O_RDONLY))
|
|
{ load_fd (); }
|
|
|
|
|
|
mapped_file::~mapped_file () {
|
|
check (m_data != NULL);
|
|
munmap (m_data, m_size);
|
|
}
|
|
|
|
|
|
void
|
|
mapped_file::load_fd (void) {
|
|
struct stat meta;
|
|
if (fstat (m_fd, &meta) < 0)
|
|
throw errno_error ();
|
|
|
|
m_size = (size_t)meta.st_size;
|
|
m_data = (uint8_t *)mmap (NULL, m_size, PROT_READ, MAP_PRIVATE, m_fd, 0);
|
|
if (m_data == MAP_FAILED)
|
|
throw errno_error ();
|
|
}
|
|
|
|
|
|
size_t
|
|
mapped_file::size (void) const {
|
|
check (m_size > 0);
|
|
check (m_data != NULL);
|
|
|
|
return m_size;
|
|
}
|
|
|
|
|
|
const uint8_t*
|
|
mapped_file::data (void) const {
|
|
check (m_size > 0);
|
|
check (m_data != NULL);
|
|
|
|
return m_data;
|
|
}
|
|
#endif
|
|
|
|
|