Flex.cc

Go to the documentation of this file.

/*
Copyright (C) 2000  Dancer A.L Vesperman

This program 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 2
of the License, or (at your option) any later version.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifndef PENTAGRAM // DONT'T INCLUDE THIS IN PENTAGRAM!

#define DEBUGFLEX 0

#include "Flex.h"

#ifndef ALPHA_LINUX_CXX
#  include <cstdio>
#endif
#include <fstream>
#include <iostream>
#include "exceptions.h"
#include "utils.h"
#include "databuf.h"

#ifndef UNDER_CE
using std::cerr;
using std::endl;
using std::FILE;
using std::memset;
using std::size_t;
using std::string;
using std::strncpy;
using std::ofstream;
using std::ios;
#endif

Flex::Flex(const string &n) : U7file(n)
{
  IndexFlexFile();
}

void  Flex::IndexFlexFile(void)
{
  FILE  *fp;
  fp=U7open(filename.c_str(),"rb");
  FileDataSource flex(fp);
  flex.read(title, sizeof(title));
  magic1 = flex.read4();
  count = flex.read4();
  magic2 = flex.read4();
  if(magic1!=0xffff1a00UL) {
    std::fclose (fp);
    throw wrong_file_type_exception(filename,"FLEX"); // Not a flex file
  }

  for(int i=0;i<9;i++)
    padding[i] = flex.read4();
#if DEBUGFLEX
  cout << "Title: " << title << endl;
  cout << "Count: " << count << endl;
#endif

  // We should already be there.
  fseek(fp,128,SEEK_SET);
  for(uint32 c=0;c<count;c++)
  {
    Flex::Reference f;
    f.offset = flex.read4();
    f.size = flex.read4();
#if DEBUGFLEX
    cout << "Item " << c << ": " << f.size << " bytes @ " << f.offset << endl;
#endif
    object_list.push_back(f);
  }
  fclose(fp);
}

char *  Flex::retrieve(uint32 objnum, size_t &len)
{
  FILE  *fp;
  char  *buffer;

  if (objnum >= object_list.size())
    throw exult_exception("objnum too large in Flex::retrieve()");

  fp = U7open(filename.c_str(), "rb");
  fseek(fp, object_list[objnum].offset, SEEK_SET);
  len = object_list[objnum].size;
  buffer = new char[len];
  std::fread(buffer, len, 1, fp);
  fclose(fp);
  
  return buffer;
}

/*
 *  Write out a FLEX header.  Note that this is a STATIC method.
 */

void Flex::write_header
  (
  DataSource* out,      // File to write to.
  const char *title,
  int count     // # entries.
  )
  {
  char titlebuf[0x50];    // Use savename for title.
  memset(titlebuf, 0, sizeof(titlebuf));
  strncpy(titlebuf, title, sizeof(titlebuf) - 1);
  out->write(titlebuf, sizeof(titlebuf));
  out->write4(0xFFFF1A00);  // Magic number.
  out->write4(count);
  out->write4(0x000000CC);  // 2nd magic number.
  long pos = out->getPos();   // Fill to data (past table at 0x80).
  long fill = 0x80 + 8*count - pos;
  while (fill--)
    out->write1((char) 0);
  }

/*
 *  Verify if a file is a FLEX.  Note that this is a STATIC method.
 */

bool Flex::is_flex(DataSource *in)
{
  long pos = in->getPos();    // Fill to data (past table at 0x80).
  long len = in->getSize() - pos; // Check length.
  uint32 magic = 0;
  if (len >= 0x80)    // Has to be at least this long.
    {
    in->seek(0x50);
    magic = in->read4();
    }
  in->seek(pos);

  // Is a flex
  if(magic==0xffff1a00UL) return true;

  // Isn't a flex
  return false;
}

bool Flex::is_flex(const char *fname)
{
  bool is = false;
  std::ifstream in;
  U7open (in, fname);
  StreamDataSource ds(&in);

  if (in.good()) is = is_flex(&ds);

  in.close();
  return is;
}

/*
 *  Start writing out a new Flex file.
 */

Flex_writer::Flex_writer
  (
  std::ofstream& o,     // Where to write.
  const char *title,    // Flex title.
  int cnt       // #entries we'll write.
  ) : out(&o), count(cnt), index(0)
  {
          // Write out header.
  StreamDataSource ds(out);
  Flex::write_header(&ds, title, count);
          // Create table.
  tptr = table = new uint8[2*count*4];
  cur_start = out->tellp(); // Store start of 1st entry.
  }

/*
 *  Clean up.
 */

Flex_writer::~Flex_writer
  (
  )
  {
  close();
  }

/*
 *  Call this when done writing out a section.
 */

void Flex_writer::mark_section_done
  (
  )
  {
  long pos = out->tellp();  // Location past end of section.
  Write4(tptr, cur_start);  // Store start of section.
  Write4(tptr, pos - cur_start);  // Store length.
  cur_start = pos;
  }

/*
 *  All done.
 *
 *  Output: False if error.
 */

bool Flex_writer::close
  (
  )
  {
  if (!table)
    return true;    // Already done.
  out->seekp(0x80, ios::beg); // Write table.
  out->write(reinterpret_cast<char*>(table), 2*count*4);
  out->flush();
  bool ok = out->good();
  out->close();
  delete table;
  table = 0;
  return ok;
  }

#endif // PENTAGRAM

---