wad.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

// C++ headers
#include <algorithm>
#include <fstream>
#include <list>
#include <sstream>
#include <string>
#include <vector>

// Doom headers
#include "global.hpp"
#include "wad.hpp"

using namespace Doomwad;

Wad::Wad (void) throw () : m_type (PWAD)
{
}

Wad::Wad (wad_type type) throw ()
{
  this->setType (type);
}

Wad::Wad (const std::string &filename) throw ()
{
  this->readFromFile (filename);
}

Wad::Wad (const Lump &lump, wad_type type) throw ()
{
  this->m_type = type;
  this->assign (1, lump);
}

bool Wad::operator== (const Wad &wad) const throw ()
{
  const_iterator iter, iter2, last;

  // Test addresses first
  if (this == &wad)
  {
    return true;
  }

  // Test primitives next
  if (this->m_type != wad.m_type || this->size () != wad.size ())
  {
    return false;
  }

  // Finally test each entry in order. Entries also use short-circuit logic, so
  // two wads that differ only by contents of their entries should return
  // fairly quickly from this method.
  for (iter = this->begin (), iter2 = wad.begin (), last = this->end (); iter != last; ++iter, ++iter2)
  {
    if (*iter != *iter2)
    {
      return false;
    }
  }
  return true;
}

bool Wad::operator!= (const Wad &wad) const throw ()
{
  return !(*this == wad);
}

Wad& Wad::operator+= (const Wad &wad) throw ()
{

  // TODO: make this smart so it overwrites entries that need to be overwritten.
  for (const_iterator iter = wad.begin (); iter != wad.end (); ++iter)
  {
    this->insert (this->end (), *iter);
  }
  return *this;
}

Wad Wad::operator+ (const Wad &wad) const throw ()
{
  Wad w (*this);
  return w += wad;
}

bool Wad::isIwad (void) const throw ()
{
  return this->m_type == IWAD;
}

bool Wad::isPwad (void) const throw ()
{
  return this->m_type == PWAD;
}

Wad::wad_type Wad::getType (void) const throw ()
{
  return this->m_type;
}

bool Wad::setType (wad_type type) throw ()
{
  this->m_type = type;
  return true;
}

std::string Wad::getWadDirectory (char delimiter) const throw ()
{
  std::ostringstream str;
  const_iterator iter = this->begin ();

  for (; iter != this->end (); ++iter)
  {
    str << iter->getName () << delimiter;
  }

  return str.str ();
}

bool Wad::writeToFile (const std::string &filename) const throw ()
{

  // File output stream
  std::ofstream out;

  // Vector that holds entry offsets for directory
  std::vector<int> dir_offset;
  dir_offset.reserve (2 * this->size ());

  // Iterators
  std::vector<int>::const_iterator iter_offset, iter_offset_end;
  Wad::const_iterator iter_lump, iter_lump_end;

  // Miscellaneous
  size_t loc_dir = 0;
  size_t lumpsize = 0;
  char buffer_name[9];
  size_t num_entries = this->size ();

  // Check filename
  if (filename.empty ())
  {
    return false;
  }

  // Open file
  out.open (filename.c_str (), std::ios::out | std::ios::binary | std::ios::trunc);
  if (!out)
  {
    return false;
  }

  // Write header
  out.write ((this->m_type == IWAD ? "IWAD" : "PWAD"), 4);
  out.write (reinterpret_cast<const char *> (&num_entries), 4);
  out.write (reinterpret_cast<const char *> (&loc_dir), 4); // should be zero the first time, actually, does not matter. Just advance the write pointer.

  // Write each entry, one at a time
  for
  (
    iter_lump = this->begin (),
    iter_lump_end = this->end ();

    iter_lump != iter_lump_end;

    ++iter_lump
  )
  {
    while (out.tellp () % 4)
    {
      out << static_cast<const char> (NULL);
    }
    dir_offset.push_back (out.tellp ());
    (*iter_lump).writeToStream (out);
  }

  // Write directory
  while (out.tellp () % 4)
  {
    out << static_cast<const char> (NULL);
  }
  for
  (
    iter_offset     = dir_offset.begin (),
    iter_offset_end = dir_offset.end (),
    iter_lump       = this->begin (),
    iter_lump_end   = this->end (),
    loc_dir         = out.tellp ();

    iter_offset != iter_offset_end
    && iter_lump != iter_lump_end;

    ++iter_offset,
    ++iter_lump
  )
  {

    // Write offset and size of lump
    out.write (reinterpret_cast<const char *> (&(*iter_offset)), 4);

    lumpsize = (*iter_lump).size ();
    out.write (reinterpret_cast<const char *> (&lumpsize), 4);

    // Write name of lump
    memset (buffer_name, '\0', 8);
    strncpy (buffer_name, (*iter_lump).getName ().c_str (), 8);
    out.write (buffer_name, 8);
  }

  // Go back to header and write the directory offset
  out.seekp (8, std::ios::beg);
  out.write (reinterpret_cast<const char *> (&loc_dir), 4);

  // All done!
  out.close ();
  return true;
}

bool Wad::readFromFile (const std::string &filename) throw ()
{

  // File insput stream
  std::ifstream in;

  // Temporary directory information
  std::vector<size_t> entry_offset, entry_size;
  std::vector<std::string> entry_name;

  // Iterators used for directory information
  std::vector<size_t>::iterator iter_offset, iter_size, iter_end;
  std::vector<std::string>::iterator iter_name;

  // Offsets and other primitives
  size_t num_entries = 0;
  size_t loc_dir = 0;
  size_t i = 0;
  char type[5];
  char buffer_dir[17];

  // Buffer for wad data
  size_t buffer_len = 0;
  char *buffer = NULL;
  Lump temp_lump;

  // Check filename
  if (filename.empty ())
  {
    return false;
  }

  // Try opening file
  in.open (filename.c_str (), std::ios::in | std::ios::binary);
  if (!in)
  {
    return false;
  }

  // Clear this object and hope for the best
  this->clear ();

  // Read the header
  in.read (type, 4);
  type[4] = 0;
  in.read (reinterpret_cast<char *> (&num_entries), 4);
  in.read (reinterpret_cast<char *> (&loc_dir), 4);

  // Parse wad type
  this->m_type = (strcmp (type, "IWAD") ? PWAD : IWAD);

  // Read directory
  in.seekg (loc_dir, std::ios::beg);
  entry_offset.reserve (2 * num_entries);
  entry_size.reserve (2 * num_entries);
  entry_name.reserve (2 * num_entries);
  for (i = buffer_dir[17] = 0; i < num_entries; ++i)
  {
    in.read (buffer_dir, 16);
    entry_offset.push_back (*(reinterpret_cast<int *> (&buffer_dir[0])));
    entry_size.push_back (*(reinterpret_cast<int *> (&buffer_dir[4])));
    entry_name.push_back (&buffer_dir[8]);
    buffer_len = std::max<size_t> (buffer_len, entry_size.back ());
  }

  // Create a buffer with the maximum needed size to avoid reallocating memory
  // each time, a relatively slow process
  buffer = new char[buffer_len];

  // Add each entry to the Wad
  for
  (
    iter_offset = entry_offset.begin (),
    iter_size   = entry_size.begin (),
    iter_end    = entry_size.end (),
    iter_name   = entry_name.begin ();

    iter_size != iter_end;

    ++iter_offset,
    ++iter_size,
    ++iter_name
  )
  {

     // Read data into buffer
     in.seekg (*iter_offset, std::ios::beg);
     in.read (buffer, *iter_size);

     // Set entry data
     temp_lump.setName (*iter_name);
     temp_lump.assign (reinterpret_cast<byte *> (buffer), *iter_size);

     this->push_back (temp_lump);
  }

  // All done!
  in.close ();
  delete [] buffer;
  return true;
}

---