lump.cpp

Go to the documentation of this file.

// libdoomwad: manipulates Doom wad files.
// Copyright (C) 2005  John Gaughan
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// This library is distributed with the full text of the LGPL. Please see
// the accompanying file named COPYING.
// 
// You may contact the author at john@johngaughan.net

// C++ required.
#if !defined __cplusplus
#error C++ compiler required
#endif

// Windows header for memory functions
#if defined WINDOWS
#include <windows.h>
#endif

// C++ headers
#include <cstring>
#include <exception>
#include <iostream>
#include <iterator>
#include <fstream>
#include <memory>
#include <new>
#include <sstream>
#include <stdexcept>
#include <string>

// Doom headers
#include "global.hpp"
#include "eventlog.hpp"
#include "lump.hpp"
#include "util.hpp"
#include "wadentry.hpp"

using namespace Doomwad;

// Constants
const size_t Lump::MAX_SIZE = std::numeric_limits<size_t>::max ();
const size_t Lump::MIN_SIZE = std::numeric_limits<size_t>::min ();

Lump::Lump (void) throw () : m_name (), m_size (0), m_data (NULL)
{
}

Lump::Lump (const Lump &lump) throw (std::bad_alloc)
{
  value_type *temp;

  // Set up member variables to default settings.
  this->m_size = 0;
  this->m_data = NULL;

  // If the source lump is not empty, copy data.
  if (lump.m_size > 0)
  {
    try
    {
      temp = new value_type[lump.m_size];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump copy constructor at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (e);
    }
    this->m_data = temp;
    this->m_size = lump.m_size;
    std::memcpy (this->m_data, lump.m_data, this->m_size);
  }

  this->m_name = lump.m_name;

  return;
}

Lump::Lump (const std::string &name, size_t length) throw (std::bad_alloc)
{
  value_type *temp;

  // Set up member variables to default settings.
  this->m_size = 0;
  this->m_data = NULL;

  if (length > 0)
  {

    // Attempt to allocate memory.
    try
    {
      temp = new value_type[length];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump constructor at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (e);
    }

    // Memory allocation succeeded. Assign buffer and size, set buffer to nulls.
    this->m_data = temp;
    this->m_size = length;
    std::memset (this->m_data, 0, this->m_size);
  }

  this->m_name = name;

  return;
}

Lump::Lump (const std::string &name, size_t length, const_pointer data) throw (std::bad_alloc, std::invalid_argument)
{
  value_type *temp;

  // Set up member variables to default settings.
  this->m_size = 0;
  this->m_data = NULL;

  // Beer good, null pointer bad!
  if ((data == NULL) && (length > 0))
  {
    std::ostringstream str;
    str << "Throwing std::invalid_argument in Lump constructor at " << __FILE__ ":" << __LINE__ << " because a null pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::invalid_argument ( exceptionString ("Null pointer passed to Lump constructor.", __FILE__, __LINE__)));
  }

  // Check for invalid pointer
#if defined WINDOWS
  if (IsBadReadPtr (data, length))
  {
    std::ostringstream str;
    str << "Throwing std::invalid_argument in Lump constructor at " << __FILE__ ":" << __LINE__ << " because an invalid pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::invalid_argument ( exceptionString ("Invalid pointer passed to Lump constructor.", __FILE__, __LINE__)));
  }
#endif

  // Only allocate if the size is positive
  if (length > 0)
  {

    // Attempt to allocate memory.
    try
    {
      temp = new value_type[length];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump constructor at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (e);
    }

    // Memory allocation succeeded. Assign buffer and size, copy buffer.
    this->m_data = temp;
    this->m_size = length;
    std::memcpy (this->m_data, data, this->m_size);
  }

  this->m_name = name;

  return;
}

Lump::Lump (const_iterator &first, const_iterator &last) throw ()
{
  this->assign (first, last);
  return;
}

Lump::Lump (const WadEntry &we) throw ()
{
  (*this) = we.toLump ();
  return;
}

Lump::~Lump (void) throw ()
{
  this->clear ();
  return;
}

Lump::iterator Lump::begin (void) throw ()
{
  return iterator (this->m_data);
}

Lump::iterator Lump::end (void) throw ()
{
  return iterator (&this->m_data[this->m_size]);
}

Lump::const_iterator Lump::begin (void) const throw ()
{
  return const_iterator (this->m_data);
}

Lump::const_iterator Lump::end (void) const throw ()
{
  return const_iterator (&this->m_data[this->m_size]);
}

Lump::reverse_iterator Lump::rbegin (void) throw ()
{
  return reverse_iterator (this->end ());
}

Lump::reverse_iterator Lump::rend (void) throw ()
{
  return reverse_iterator (this->begin ());
}

Lump::const_reverse_iterator Lump::rbegin (void) const throw ()
{
  return const_reverse_iterator (this->end ());
}

Lump::const_reverse_iterator Lump::rend (void) const throw ()
{
  return const_reverse_iterator (this->begin ());
}

Lump& Lump::operator= (const Lump &lump) throw (std::bad_alloc)
{
  pointer temp;

  // Check for self-assignment
  if (this == &lump) return *this;

  // If the source is empty.
  if (lump.m_size == 0)
  {
    this->clearData ();
  }

  // Otherwise, it is not empty, copy the data.
  else
  {
    try
    {
      temp = new value_type[lump.m_size];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump::operator= at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (e);
    }
    std::memcpy (temp, lump.m_data, lump.m_size);
    this->clearData ();
    this->m_data = temp;
    this->m_size = lump.m_size;
  }

  // Copy the name last.
  this->m_name = lump.m_name;

  return *this;
}

Lump& Lump::operator= (const WadEntry &we) throw (std::bad_alloc)
{
  *this = we.toLump ();
  return *this;
}

Lump& Lump::operator+= (const Lump &lump) throw (std::bad_alloc, std::range_error)
{
  pointer temp;
  size_t length;

  // Ensure the new size is not a size_t overflow
  if ((MAX_SIZE - this->m_size) < lump.m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::operator+=() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("New size too large in Lump::operator+=().", __FILE__, __LINE__)));
  }

  // Only append if there is data to append.
  if (lump.m_size > 0)
  {

    // If this object is empty, just copy the data over.
    if (this->m_size == 0)
    {
      try
      {
        this->m_data = new value_type[lump.m_size];
      }
      catch (std::bad_alloc &e)
      {
        std::ostringstream str;
        str << "Caught std::bad_alloc in Lump::operator+= at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
        std::string string (str.str ());
        EventLog::printLine (string);
        this->m_data = NULL;
        throw (e);
      }
      this->m_size = lump.m_size;
      std::memcpy (this->m_data, lump.m_data, this->m_size);
    }

    // Neither Lump empty. Concatenate.
    else
    {
      try
      {
        temp = new value_type[this->m_size + lump.m_size];
      }
      catch (std::bad_alloc &e)
      {
        std::ostringstream str;
        str << "Caught std::bad_alloc in Lump::operator+= at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
        std::string string (str.str ());
        EventLog::printLine (string);
        throw (e);
      }

      std::memcpy (temp, this->m_data, this->m_size);
      std::memcpy (&temp[this->m_size], lump.m_data, lump.m_size);
      length = this->m_size + lump.m_size;

      this->clearData ();
      this->m_data = temp;
      this->m_size = length;
    }
  }

  return *this;
}

Lump Lump::operator+ (const Lump &lump) const throw (std::bad_alloc, std::range_error)
{
  Lump temp;
  pointer buffer;

  // Ensure the new size is not a size_t overflow
  if ((MAX_SIZE - this->m_size) < lump.m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump operator+ at " << __FILE__ ":" << __LINE__ << " because the new Lump size is too large. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("New size too large in Lump::operator+().", __FILE__, __LINE__)));
  }

  // If this is empty but lump is not, assign lump.
  if ((this->m_size == 0) && (lump.m_size != 0))
  {
    temp = lump;
    temp.m_name = this->m_name;
  }

  // If lump is empty but this is not, assign this.
  else if ((this->m_size != 0) && (lump.m_size == 0))
  {
    temp = *this;
  }

  // If neither is empty, concatenate.
  else if ((this->m_size != 0) && (lump.m_size != 0))
  {
    try
    {
      buffer = new value_type[this->m_size + lump.m_size];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump operator+ at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (e);
    }

    std::memcpy (buffer, this->m_data, this->m_size);
    std::memcpy (&buffer[this->m_size], lump.m_data, lump.m_size);

    temp.m_data = buffer;
    temp.m_size = this->m_size + lump.m_size;
    temp.m_name = this->m_name;
  }

  return temp;
}

bool Lump::operator== (const Lump &lump) const throw ()
{
  return (this->m_size == lump.m_size) && (this->m_name == lump.m_name) && (std::memcmp (this->m_data, lump.m_data, this->m_size) == 0);
}

bool Lump::operator!= (const Lump &lump) const throw ()
{
  return (this->m_size != lump.m_size) || (this->m_name != lump.m_name) || (std::memcmp (this->m_data, lump.m_data, this->m_size) != 0);
}

Lump::operator std::string& (void) throw ()
{
  return this->m_name;
}

Lump::operator size_t (void) throw ()
{
  return this->m_size;
}

Lump::operator bool (void) throw ()
{
  return this->m_size > 0;
}

Lump::reference Lump::operator[] (size_t offset) throw ()
{
  return (this->m_data)[offset];
}

Lump::const_reference Lump::operator[] (size_t offset) const throw ()
{
  return (this->m_data)[offset];
}

Lump::reference Lump::at (size_t offset) throw (std::out_of_range)
{
  if (offset >= this->m_size)
  {
    std::ostringstream str;
    str << "Throwing std::out_of_range in Lump::at() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::out_of_range (exceptionString ("Index out of bounds in Lump::at().", __FILE__, __LINE__)));
  }
  return (this->m_data)[offset];
}

Lump::const_reference Lump::at (size_t offset) const throw (std::out_of_range)
{
  if (offset >= this->m_size)
  {
    std::ostringstream str;
    str << "Throwing std::out_of_range in Lump::at() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::out_of_range (exceptionString ("Index out of bounds in Lump::at() const.", __FILE__, __LINE__)));
  }
  return (this->m_data)[offset];
}

bool Lump::append (const_pointer data, size_t length) throw (std::invalid_argument, std::range_error)
{
  pointer temp;
  size_t newsize;

  // Ensure the new size is not a size_t overflow. Be careful when checking so
  // the "if" statement does not overflow either.
  if ((MAX_SIZE - this->m_size) < length)
  {
    std::ostringstream str;
    str << "Throwing std::out_of_range in Lump::append() at " << __FILE__ ":" << __LINE__ << " because the new size is too large. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("New size too large in Lump::append().", __FILE__, __LINE__)));
  }

  // If the new size is zero, do nothing
  if (length > 0)
  {

    // Hurry up and throw the damn exception
    if (data == NULL)
    {
      std::ostringstream str;
      str << "Throwing std::invalid_argument in Lump::append() at " << __FILE__ ":" << __LINE__ << " because a null pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (std::invalid_argument (exceptionString ("Null pointer passed to Lump::append().", __FILE__, __LINE__)));
    }

    // Check for invalid pointer
#if defined WINDOWS
    if (IsBadReadPtr (data, length))
    {
      std::ostringstream str;
      str << "Throwing std::invalid_argument in Lump::append() at " << __FILE__ ":" << __LINE__ << " because an invalid pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      throw (std::invalid_argument ( exceptionString ("Invalid pointer passed to Lump constructor.", __FILE__, __LINE__)));
    }
#endif

    // Allocate and copy memory
    newsize = this->m_size + length;
    try
    {
      temp = new value_type[newsize];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump::append() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      return false;
    }
    std::memcpy (temp, this->m_data, this->m_size);
    std::memcpy (&temp[this->m_size], data, length);

    // Assign to this
    this->clearData ();
    this->m_data = temp;
    this->m_size = newsize;
  }

  return true;
}

bool Lump::append (const_iterator &first, const_iterator &last) throw (std::range_error)
{
  try
  {
    return this->append (&(*first), std::distance<const_iterator>(first, last));
  }

  // Should not happen
  catch (std::invalid_argument &e)
  {
  }
  return false;
}

bool Lump::assign (const_pointer data, size_t length) throw (std::invalid_argument, std::bad_alloc)
{
  pointer temp;

  // Null pointer.
  if (data == NULL && length > 0)
  {
    std::ostringstream str;
    str << "Throwing std::invalid_argument in Lump::assign() at " << __FILE__ ":" << __LINE__ << " because a null pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::invalid_argument (exceptionString ("Null pointer passed to Lump::assign().", __FILE__, __LINE__)));
  }

  // Check for invalid pointer
#if defined WINDOWS
  if (IsBadReadPtr (data, length))
  {
    std::ostringstream str;
    str << "Throwing std::invalid_argument in Lump::assign() at " << __FILE__ ":" << __LINE__ << " because an invalid pointer was passed in. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::invalid_argument ( exceptionString ("Invalid pointer passed to Lump constructor.", __FILE__, __LINE__)));
  }
#endif

  // Clear data.
  if (length == 0)
  {
    return this->clearData ();
  }

  // Size is positive, pointer is not null. Create temporary buffer. Pass
  // bad_alloc exception through to calling process.
  temp = new value_type[length];
  std::memcpy (temp, data, length);

  this->clearData ();
  this->m_data = temp;
  this->m_size = length;

  return true;
}

bool Lump::assign (const_iterator &first, const_iterator &last) throw (std::bad_alloc)
{
  try
  {
    return this->assign (&(*first), std::distance<const_iterator>(first, last));
  }

  // Should not be possible
  catch (std::invalid_argument &e)
  {
  }
  return false;
}

std::string Lump::getName (void) const throw ()
{
  return this->m_name;
}

bool Lump::setName (const std::string &name) throw ()
{

  // 26 Nov 2004 (JTG): fixed bug with string overflow on 8 character strings.
  this->m_name = name.substr (0, 8);
  return true;
}

Lump::const_pointer Lump::getData (void) throw ()
{
  return this->m_data;
}

bool Lump::grow (size_t amount) throw (std::range_error, std::bad_alloc)
{

  // Check for range error.
  if ((MAX_SIZE - this->m_size) < amount)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::grow() at " << __FILE__ ":" << __LINE__ << " because the new size is too large. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("New size too large in Lump::grow().", __FILE__, __LINE__)));
  }

  // Call setSize() and do not handle bad_alloc: pass it through to caller.
  return this->setSize (this->m_size + amount);
}

bool Lump::shrink (size_t amount) throw (std::range_error, std::bad_alloc)
{

  // Check for range error.
  if (this->m_size < amount)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::shrink() at " << __FILE__ ":" << __LINE__ << " because the new size is negative. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("New size too small in Lump::shrink().", __FILE__, __LINE__)));
  }

  // Call setSize() and do not handle bad_alloc: pass it through to caller.
  return this->setSize (this->m_size - amount);
}

bool Lump::setSize (size_t length) throw (std::bad_alloc)
{
  pointer temp;

  // Check for zero size.
  if (length == 0)
  {
    this->clearData ();
  }

  // Check for same size.
  if (this->m_size != length)
  {

    // Try to allocate the new buffer.
    try
    {
      temp = new value_type[length];
    }
    catch (std::bad_alloc &e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump::setSize() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      this->m_data = NULL;
      throw (e);
    }

    // If the size is shrinking, only copy part of the buffer.
    if (length < this->m_size)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump::setSize() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      std::memcpy (temp, this->m_data, length);
    }

    // If the size is growing, copy the whole buffer and pad with nulls.
    else
    {
      std::memcpy (temp, this->m_data, this->m_size);
      std::memset (&temp[this->m_size], 0, length - this->m_size);
    }

    // Reassign pointer and size.
    this->clearData ();
    this->m_data = temp;
    this->m_size = length;
  }

  return true;
}

bool Lump::readFromFile (std::ifstream &file) throw (std::bad_alloc)
{
  const size_t buffer_length = 32 * 1024;
  value_type buffer[buffer_length];
  Lump temp;

  // Not all istreams are random access, so we must read sequentially into a
  // buffer and append this buffer. 32kb chunks are realistically efficient for
  // wad lumps because they are generally not all that big. If a Linedef takes
  // 14 bytes, a 32kb buffer can store 2,340 Linedefs.

  // Only read if the stream is ready
  if (file.is_open ())
  {
    while (file.good ())
    {
      file.read (reinterpret_cast<char *> (buffer), buffer_length);
      temp.append (buffer, file.gcount ());
    }
  }
  return this->assign (temp.m_data, temp.m_size);
}

bool Lump::readFromFile (const std::string &filename) throw ()
{
  bool result;
  std::ifstream in (filename.c_str (), std::ios::binary | std::ios::in);
  try
  {
    result = this->readFromFile (in);
  }
  catch (std::bad_alloc &e)
  {
    std::ostringstream str;
    str << "Caught std::bad_alloc in Lump::readFromFile() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    result = false;
  }
  return result;
}

bool Lump::writeToFile (std::ofstream &file) const throw ()
{

  // Only write if the stream is ready to accept output
  if (file.is_open () && file.good ())
  {
    file.write (reinterpret_cast<char *> (this->m_data), this->m_size);
  }

  else
  {
    return false;
  }

  file.flush ();
  return true;
}

bool Lump::writeToFile (const std::string &filename) const throw ()
{
  std::ofstream out (filename.c_str (), std::ios::binary | std::ios::out | std::ios::trunc);
  bool result = this->writeToFile (out);
  out.close ();
  return result;
}

bool Lump::readFromStream (std::istream &stream, size_t bytes) throw ()
{
  value_type *temp = NULL;
  if (stream)
  {
    try
    {
      temp = new value_type[bytes];
      stream.read (reinterpret_cast<char *> (temp), bytes);
    }
    catch (std::bad_alloc e)
    {
      std::ostringstream str;
      str << "Caught std::bad_alloc in Lump::readFromStream() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      return false;
    }
    catch (...)
    {
      std::ostringstream str;
      str << "Caught unknown exception in Lump::readFromStream() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      delete [] temp;
      return false;
    }
    delete [] this->m_data;
    this->m_data = temp;
    this->m_size = bytes;
  }
  else
  {
    return false;
  }
  return true;
}

bool Lump::writeToStream (std::ostream &stream) const throw ()
{
  if (stream)
  {
    try
    {
      stream.write (reinterpret_cast<char *> (this->m_data), this->m_size);
    }
    catch (...)
    {
      std::ostringstream str;
      str << "Caught unknown exception in Lump::writeToStream() at " << __FILE__ ":" << __LINE__ << ". this=" << (reinterpret_cast<size_t> (this));
      std::string string (str.str ());
      EventLog::printLine (string);
      return false;
    }
  }
  else
  {
    return false;
  }
  return true;
}

bool Lump::writeToTextStream (std::ostream &stream, size_t wrap, char nonprint) const throw ()
{
  const_iterator iter = this->begin ();
  const_iterator iter_end = this->end ();
  size_t line = 0;

  // Only write if the stream is ready to accept output.
  if (stream)
  {

    // Print each character, substituting nonprinting characters.
    for (; iter != iter_end; ++iter, ++line)
    {
      if ((line == wrap) && (wrap != 0))
      {
        line = 0;
        stream << '\n';
      }
      stream << (std::isprint (*iter) ? *iter : nonprint);
    }
  }
  else
  {
    return false;
  }
  return true;
}

bool Lump::clear (void) throw ()
{
  this->clearData ();
  this->clearName ();
  return true;
}

bool Lump::clearData (void) throw ()
{
  if (this->m_size > 0)
  {
    delete [] this->m_data;
    this->m_data = NULL;
    this->m_size = 0;
  }
  return true;
}

bool Lump::clearName (void) throw ()
{
  this->m_name.clear ();
  return true;
}

bool Lump::empty (void) const throw ()
{
  return this->m_size == 0;
}

size_t Lump::size (void) const throw ()
{
  return this->m_size;
}

Doomwad::byte Lump::getByte (size_t index) const throw (std::range_error)
{
  if (index + sizeof (byte) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getByte() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getByte().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<byte *> (&this->m_data[index]));
}

word Lump::getWord (size_t index) const throw (std::range_error)
{
  if (index + sizeof (word) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getWord().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<word *> (&this->m_data[index]));
}

dword Lump::getDWord (size_t index) const throw (std::range_error)
{
  if (index + sizeof (dword) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getDWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getDWord().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<dword *> (&this->m_data[index]));
}

qword Lump::getQWord (size_t index) const throw (std::range_error)
{
  if (index + sizeof (qword) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getQWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getQWord().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<qword *> (&this->m_data[index]));
}

int8 Lump::getInt8 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (int8) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getInt8() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getInt8().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<int8 *> (&this->m_data[index]));
}

uint8 Lump::getUInt8 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (uint8) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getUInt8() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getUInt8().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<uint8 *> (&this->m_data[index]));
}

int16 Lump::getInt16 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (int16) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getInt16() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getInt16().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<int16 *> (&this->m_data[index]));
}

uint16 Lump::getUInt16 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (uint16) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getUInt16() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getUInt16().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<uint16 *> (&this->m_data[index]));
}

int32 Lump::getInt32 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (int32) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getInt32() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getInt32().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<int32 *> (&this->m_data[index]));
}

uint32 Lump::getUInt32 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (uint32) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getUInt32() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getUInt32().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<uint32 *> (&this->m_data[index]));
}

int64 Lump::getInt64 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (int64) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getInt64() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getInt64().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<int64 *> (&this->m_data[index]));
}

uint64 Lump::getUInt64 (size_t index) const throw (std::range_error)
{
  if (index + sizeof (uint64) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getUInt64() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getUInt64().", __FILE__, __LINE__)));
  }
  return *(reinterpret_cast<uint64 *> (&this->m_data[index]));
}

bool Lump::setByte (byte n, size_t index) throw (std::range_error)
{
  if (index + sizeof (byte) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setByte() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setByte().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<byte *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setWord (word n, size_t index) throw (std::range_error)
{
  if (index + sizeof (word) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setWord().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<word *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setDWord (dword n, size_t index) throw (std::range_error)
{
  if (index + sizeof (dword) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setDWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setDWord().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<dword *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setQWord (qword n, size_t index) throw (std::range_error)
{
  if (index + sizeof (qword) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setQWord() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setQWord().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<qword *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setInt8 (int8 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (int8) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setInt8() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setInt8().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<int8 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setUInt8 (uint8 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (uint8) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setUInt8() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setUInt8().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<uint8 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setInt16 (int16 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (int16) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setInt16() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setInt16().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<int16 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setUInt16 (uint16 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (uint16) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setUInt16() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setUInt16().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<uint16 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setInt32 (int32 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (int32) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setInt32() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setInt32().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<int32 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setUInt32 (uint32 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (uint32) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setUInt32() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setUInt32().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<uint32 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setInt64 (int64 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (int64) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setInt64() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setInt64().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<int64 *> (&this->m_data[index])) = n;
  return true;
}

bool Lump::setUInt64 (uint64 n, size_t index) throw (std::range_error)
{
  if (index + sizeof (uint64) - 1 >= m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::setUInt64() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setUInt64().", __FILE__, __LINE__)));
  }
  *(reinterpret_cast<uint64 *> (&this->m_data[index])) = n;
  return true;
}

std::string Lump::getString (size_t index) const throw (std::range_error)
{
  if (index >= this->m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getString() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getString().", __FILE__, __LINE__)));
  }
  size_t length = std::strlen (reinterpret_cast<const char *> (&this->m_data[index]));
  if (length > this->m_size - index) length = this->m_size - index;
  std::string str (reinterpret_cast<std::string::value_type *> (&(this->m_data[index])), length);
  return str;
}

std::string Lump::getDString (size_t index) const throw (std::range_error)
{
  std::ostringstream out;
  if (index + 8 >= this->m_size)
  {
    std::ostringstream str;
    str << "Throwing std::range_error in Lump::getDString() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (str.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::getDString().", __FILE__, __LINE__)));
  }
  for (size_t i = index; i < index + 8 && this->m_data[i] != 0; ++i)
  {
    out << this->m_data[i];
  }
  out << '\0';
  return out.str ();
}

bool Lump::setString (const std::string &str, size_t index) throw (std::range_error)
{
  if (index + str.size () >= this->m_size)
  {
    std::ostringstream ostr;
    ostr << "Throwing std::range_error in Lump::setString() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (ostr.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setString().", __FILE__, __LINE__)));
  }
  std::strncpy (reinterpret_cast<char *> (&(this->m_data[index])), str.c_str (), this->m_size - index);
  return true;
}

bool Lump::setDString (const std::string &str, size_t index) throw (std::range_error)
{
  if (index + 8 >= this->m_size)
  {
    std::ostringstream ostr;
    ostr << "Throwing std::range_error in Lump::setDString() at " << __FILE__ ":" << __LINE__ << " because the index is out of bounds. this=" << (reinterpret_cast<size_t> (this));
    std::string string (ostr.str ());
    EventLog::printLine (string);
    throw (std::range_error (exceptionString ("Index out of bounds in Lump::setDString().", __FILE__, __LINE__)));
  }

  size_t l = index;
  std::string::const_iterator s = str.begin ();

  for (; l < index + 8 && s != str.end (); ++l, ++s)
  {
    this->m_data[l] = *s;
  }
  for (; l < index + 8; ++l)
  {
    this->m_data[l] = 0;
  }

  return true;
}

---