794 lines
21 KiB
C++
Executable File
794 lines
21 KiB
C++
Executable File
//
|
|
// GLARC.CPP
|
|
//
|
|
// Source file for ArchiveLib 2.0
|
|
//
|
|
// Copyright (c) Greenleaf Software, Inc. 1994-1996
|
|
// All Rights Reserved
|
|
//
|
|
// CONTENTS
|
|
//
|
|
// ALGlArchive::operator new()
|
|
// ALGlArchive::ALGlArchive()
|
|
// newALGlArchiveFromStorage()
|
|
// ALGlArchive::~ALGlArchive()
|
|
// ALGlArchive::PreWriteDir()
|
|
// ALGlArchive::PostWriteDir()
|
|
// ALGlArchive::WriteDirEntry()
|
|
// ALGlArchive::ReadDirectory()
|
|
// ALGlArchive::PreCreate()
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This file contains all of the source code for the base class,
|
|
// ALGlArchive. The details on how things get inserted and extracted from an
|
|
// archive will all be found here.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 23, 1994 1.0A : First release
|
|
//
|
|
// July 7, 1994 1.0B : Minor change to handle a snag with the sun
|
|
// compilers.
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
#include "arclib.h"
|
|
#if !defined( AL_IBM )
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
#include "glarc.h"
|
|
#include "_openf.h"
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::operator new()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Memory allocator used when ArchiveLib resides in a 16 bit DLL.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// void * ALGlArchive::operator new( size_t size )
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// size : The number of bytes that the compiler has decided will be
|
|
// necessary to construct a new ALGlArchive object.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// When using a DLL, it is easy to get into a dangerous situation when
|
|
// creating objects whose ctor and dtor are both in the DLL. The problem
|
|
// arises because when you create an object using new, the memory for
|
|
// the object will be allocated from the EXE. However, when you destroy
|
|
// the object using delete, the memory is freed inside the DLL. Since
|
|
// the DLL doesn't really own that memory, bad things can happen.
|
|
//
|
|
// But, you say, won't the space just go back to the Windows heap regardless
|
|
// of who tries to free it? Maybe, but maybe not. If the DLL is using
|
|
// a subsegment allocation scheme, it might do some sort of local free
|
|
// before returning the space to the windows heap. That is the point where
|
|
// you could conceivably cook your heap.
|
|
//
|
|
// By providing our own version of operator new inside this class, we
|
|
// ensure that all memory allocation for the class will be done from
|
|
// inside the DLL, not the EXE calling the DLL.
|
|
//
|
|
// This function will be called whenever you dynamically create a new
|
|
// ALGlArchive object (using the new operator.)
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A pointer to some memory that should have been pulled out of the
|
|
// heap for the DLL.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
#if defined( AL_BUILDING_DLL )
|
|
|
|
void AL_DLL_FAR * AL_PROTO
|
|
ALGlArchive::operator new( size_t size ) /* Tag internal function */
|
|
{
|
|
return ::new char[ size ];
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::ALGlArchive()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++ C VB Delphi
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// The Greenleaf Archive constructors.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// ALGlArchive::ALGlArchive( ALStorage &storage_object );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// hALArchive newALGlArchiveFromStorage( hALStorage storage );
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// Declare Function newALGlArchiveFromStorage Lib "AL20LW"
|
|
// (ByVal storage&) As Long
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// function newALGlArchiveFromStorage( storage : hALStorage ) : hALArchive;
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// storage_object : A pointer to the storage object that will/does
|
|
// hold the archive.
|
|
//
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function creates a new ALGlArchive object, using a storage object
|
|
// as the underlying physical container. GlArchives are siblings to
|
|
// Pk archives. While they both use the same base class, and support many
|
|
// functions in common, they are essentially incompatible.
|
|
//
|
|
// You call this constructor to manipulate any archive, including ones
|
|
// that haven't even been created yet.
|
|
//
|
|
// Recall that the base class, ALArchive, has a single argument to *its*
|
|
// constructor that determines whether or not it destroys the underlying
|
|
// storage object in its destructor. Since we are using user-specified
|
|
// storage in this case, we pass a 0, indicating that we don't want the
|
|
// destructor to destroy the underlying storage object.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// When called from C/VB/Delphi, the translation function returns a handle
|
|
// to a newly created archive object. When called using the new operator
|
|
// in C++, this function returns a pointer to a newly created archive
|
|
// object.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
AL_PROTO
|
|
ALGlArchive::ALGlArchive( ALStorage AL_DLL_FAR &storage_object ) /* Tag public function */
|
|
: ALArchive( &storage_object, 0)
|
|
{
|
|
miVersion = 0x100;
|
|
}
|
|
|
|
#if !defined( AL_NO_C )
|
|
|
|
extern "C" AL_LINKAGE hALArchive AL_FUNCTION
|
|
newALGlArchiveFromStorage( hALStorage storage ) /* Tag public function */
|
|
{
|
|
AL_ASSERT( ( (ALStorage *) storage)->GoodTag(),
|
|
"storage argument is not a valid ALStorageObject" );
|
|
ALArchive *archive;
|
|
archive = new ALGlArchive( *(ALStorage *) storage );
|
|
return (hALArchive) archive;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::~ALGlArchive()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Destructor for the Greenleaf Archive.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// ALGlArchive::~ALGlArchive()
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, use deleteALArchive();
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, use deleteALArchive();
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, use deleteALArchive();
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is a virtual destructor for the derived class ALGlArchive. It
|
|
// has absolutely nothing to do, since all of the important work is done
|
|
// by the base class destructor, ALArchive::~ALArchive(). Note that
|
|
// there is no translation function for C/VB/Delphi to call this function
|
|
// directly. Instead, they will get here by way of a virtual function
|
|
// call to the base class destructor.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
AL_PROTO
|
|
ALGlArchive::~ALGlArchive() /* Tag public function */
|
|
{
|
|
AL_ASSERT( GoodTag(), "~ALGlArchive(): Attempting to delete invalid ALGlArchive" );
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::PreWriteDir()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Write out the archive data that precedes the directory.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// void ALGlArchive::PreWriteDir()
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// The base class, ALArchive, is responsible for all the work done when
|
|
// creating an archive. However, since Greenleaf and PKWare archives
|
|
// are fairly different, the base class relies on a few virtual functions
|
|
// to perform archive specific chores.
|
|
//
|
|
// PreWriteDir() is one of those functions. It is called after the
|
|
// file pointer has been positioned to write the directory out, but
|
|
// before any directory entries have been written.
|
|
//
|
|
// Greenleaf archives store three items directly ahead of the
|
|
// directory: the archive version, any customized archive data, and
|
|
// the archive comment. This routine just writes all those out, then
|
|
// returns to the calling routine. The caller is presumably the
|
|
// write directory code in ALArchive, and it should continue by writing
|
|
// out all of its directory entries.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
void AL_PROTO
|
|
ALGlArchive::PreWriteDir() /* Tag protected function */
|
|
{
|
|
mpArchiveStorageObject->WriteGlShort( miVersion );
|
|
WriteArchiveData();
|
|
mpArchiveStorageObject->WriteString( mComment );
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::PostWriteDir()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Write out the archive data that follows the directory.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// void ALGlArchive::PostWriteDir()
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, this is an internal function.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// The base class, ALArchive, is responsible for all the work done when
|
|
// creating an archive. However, since Greenleaf and PKWare archives
|
|
// are fairly different, the base class relies on a few virtual functions
|
|
// to perform archive specific chores.
|
|
//
|
|
// PostWriteDir() is one of those functions. It is called after the
|
|
// directory entires for the archive have all been written out.
|
|
//
|
|
// Greenleaf archives store three items directly ahead of the
|
|
// directory: the archive version, any customized archive data, and
|
|
// the archive comment. This routine just writes all those out, then
|
|
// returns to the calling routine. The caller is presumably the
|
|
// write directory code in ALArchive, and it should continue by writing
|
|
// out all of its directory entries.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
void AL_PROTO
|
|
ALGlArchive::PostWriteDir() /* Tag protected function */
|
|
{
|
|
long keeper = mpArchiveStorageObject->Tell();
|
|
mpArchiveStorageObject->WriteString( "" );
|
|
mpArchiveStorageObject->Seek( 0L );
|
|
mpArchiveStorageObject->WriteGlLong( mlDirectoryOffset );
|
|
|
|
mpArchiveStorageObject->Seek( keeper );
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::WriteDirEntry()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Write an individual object entry to the archive directory.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// void ALGlArchive::WriteDirEntry( ALEntry &entry );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// entry : A reference to an entry. This should correspond to an actual
|
|
// object that is present in the archive.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// The base class function, ALArchive::WriteDirectory(), sits in a loop
|
|
// writing out directory entries, one after the other. Since it is in
|
|
// the base class, you can't expect it to know the exact format for an
|
|
// entry. So instead, it relies on this virtual function in derived
|
|
// classes to do the job.
|
|
//
|
|
// This function takes care of writing out a directory entry in the format
|
|
// Greenleaf archives use.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
void AL_PROTO
|
|
ALGlArchive::WriteDirEntry( ALEntry AL_DLL_FAR &entry ) /* Tag protected function */
|
|
{
|
|
mpArchiveStorageObject->WriteString( entry.mpStorageObject->mName.GetSafeName() );
|
|
if ( entry.mpCompressor ) {
|
|
mpArchiveStorageObject->WriteChar( entry.mpCompressor->miCompressionType );
|
|
entry.mpCompressor->WriteEngineData( mpArchiveStorageObject );
|
|
} else if ( entry.mpDecompressor ) {
|
|
mpArchiveStorageObject->WriteChar( entry.mpDecompressor->miCompressionType );
|
|
entry.mpDecompressor->WriteEngineData( mpArchiveStorageObject );
|
|
} else {
|
|
mStatus.SetError( AL_UNKNOWN_COMPRESSION_TYPE,
|
|
"No compressor or decompressor for archive"
|
|
" entry %s",
|
|
entry.mpStorageObject->mName.GetSafeName() );
|
|
return;
|
|
}
|
|
mpArchiveStorageObject->WriteChar( entry.mpStorageObject->miStorageObjectType );
|
|
entry.mpStorageObject->WriteStorageObjectData( mpArchiveStorageObject );
|
|
|
|
mpArchiveStorageObject->WriteGlLong( entry.mpStorageObject->GetSize() );
|
|
mpArchiveStorageObject->WriteGlLong( entry.GetCompressedSize() );
|
|
mpArchiveStorageObject->WriteGlLong( entry.GetCrc32() );
|
|
mpArchiveStorageObject->WriteGlLong( entry.mlCompressedObjectPosition );
|
|
mpArchiveStorageObject->WriteString( entry.GetComment() );
|
|
mpArchiveStorageObject->WriteGlLong( entry.mpStorageObject->mTimeDate.GetUnixTime() );
|
|
mpArchiveStorageObject->WriteGlShort( entry.mpStorageObject->mAttributes.PackedAttributes() );
|
|
if ( mpArchiveStorageObject->mStatus < 0 )
|
|
mStatus = mpArchiveStorageObject->mStatus;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALGlArchive::ReadDirectory()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Read in the directory for a GL format archive.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// int ALGlArchive::ReadDirectory( ALEntryList &list )
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, internal function.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, internal function.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, internal function.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// list : An ALEntryList object that is going to receive all the
|
|
// new ALEntry objects created from reading the directory.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// During the process of creating ArchiveLib 2.0, the WriteDirectory()
|
|
// function was moved up into the base class. The addition of three
|
|
// virtual helper functions takes care of all the specialized aspects
|
|
// needed to make it happen.
|
|
//
|
|
// Well, I haven't gotten around to that for the ReadDirectory function.
|
|
// Maybe in the final release of 2.0, but more likely in the release
|
|
// of ArchiveLib 3.0. It's not a critical issue, it just helps break
|
|
// the code down into smaller pieces, and is somewhat more efficient by
|
|
// sharing common code.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS or < AL_SUCCESS if things don't work.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
|
|
int AL_PROTO
|
|
ALGlArchive::ReadDirectory( ALEntryList AL_DLL_FAR &list ) /* Tag protected function */
|
|
{
|
|
list.mrMonitor.ArchiveOperation( AL_START_DIRECTORY_READ, this, 0 );
|
|
ALOpenInputFile archive( *mpArchiveStorageObject );
|
|
if ( mpArchiveStorageObject->mStatus < 0 )
|
|
return mStatus = mpArchiveStorageObject->mStatus;
|
|
//
|
|
// First I seek to the start of the directory (offset found at 0), and
|
|
// read in the version. This function only supports the directory
|
|
// structure defined in version 0x100.
|
|
//
|
|
mpArchiveStorageObject->Seek( 0 );
|
|
mpArchiveStorageObject->ReadGlLong( mlDirectoryOffset );
|
|
mpArchiveStorageObject->Seek( mlDirectoryOffset );
|
|
mpArchiveStorageObject->ReadGlShort( miVersion );
|
|
if ( miVersion != 0x100 )
|
|
return mStatus.SetError( AL_INVALID_ARCHIVE,
|
|
"%s is not a valid archive file",
|
|
mpArchiveStorageObject->mName.GetSafeName() );
|
|
//
|
|
// Read in any customized archive data defined by a derived class.
|
|
//
|
|
ReadArchiveData();
|
|
//
|
|
// Read in the comment, deleting the old one if necessary.
|
|
//
|
|
mpArchiveStorageObject->ReadString( mComment );
|
|
//
|
|
// Now, the big loop. I have to read in each entry, one at a time, and
|
|
// add it to the list. If I broke this out into a separate routine it
|
|
// would make the whole thing a lot more manageable.
|
|
//
|
|
for ( ; ; ) {
|
|
if ( mpArchiveStorageObject->mStatus < 0 )
|
|
return mStatus = mpArchiveStorageObject->mStatus;
|
|
ALName name;
|
|
mpArchiveStorageObject->ReadString( name );
|
|
//
|
|
// The directory ends with a blank name.
|
|
//
|
|
if ( strlen( name ) == 0 )
|
|
break;
|
|
//
|
|
// Derived classes are responsible for providing a version of
|
|
// CreateCompressionEngine() that will convert the engine_type
|
|
// integer into a created compression engine. The derived class is
|
|
// then also responsible for reading in the engine data from the archive.
|
|
//
|
|
int engine_type = mpArchiveStorageObject->ReadChar();
|
|
ALCompressor *compressor = 0;
|
|
ALDecompressor *decompressor = list.mToolKit.CreateDecompressor( engine_type );
|
|
if ( decompressor )
|
|
decompressor->ReadEngineData( mpArchiveStorageObject );
|
|
else {
|
|
compressor = list.mToolKit.CreateCompressor( engine_type );
|
|
if ( compressor )
|
|
compressor->ReadEngineData( mpArchiveStorageObject );
|
|
else {
|
|
ALName temp;
|
|
mpArchiveStorageObject->ReadString( temp );
|
|
//
|
|
// I used to treat this as an error, now I don't. The error will come about
|
|
// when you actually try to decompress the object.
|
|
//
|
|
#if 0
|
|
return mStatus.SetError( AL_CANT_CREATE_ENGINE,
|
|
"Failure creating compression engine for object %s",
|
|
(const char *) name );
|
|
#endif
|
|
}
|
|
}
|
|
//
|
|
// Now we go through a nearly identical process to create the storage object.
|
|
// The derived class is responsible for writing a CreateStorageObject()
|
|
// function that converts an object_type integer to a created storage
|
|
// object. The derived class also has to read in the storage object
|
|
// data.
|
|
//
|
|
int object_type = mpArchiveStorageObject->ReadChar();
|
|
ALStorage *storage_object = list.mToolKit.CreateStorageObject( name, object_type );
|
|
if ( storage_object )
|
|
storage_object->ReadStorageObjectData( mpArchiveStorageObject );
|
|
else {
|
|
ALName temp;
|
|
mpArchiveStorageObject->ReadString( temp );
|
|
//
|
|
// I used to treat this as an error, now I don't. The error will come about
|
|
// when you actually try to compress the object.
|
|
//
|
|
#if 0
|
|
return mStatus.SetError( AL_CANT_CREATE_STORAGE_OBJECT,
|
|
"Failure creating storage object for object %s",
|
|
(const char *) name );
|
|
#endif
|
|
}
|
|
//
|
|
// The rest of the stuff in the entry is pretty straightforward.
|
|
//
|
|
mpArchiveStorageObject->ReadGlLong( storage_object->mlSize );
|
|
ALEntry *job = new ALEntry( list, storage_object, compressor, decompressor );
|
|
mpArchiveStorageObject->ReadGlLong( job->mlCompressedSize );
|
|
mpArchiveStorageObject->ReadGlLong( job->mlCrc32 );
|
|
mpArchiveStorageObject->ReadGlLong( job->mlCompressedObjectPosition );
|
|
ALName comment;
|
|
mpArchiveStorageObject->ReadString( comment );
|
|
job->SetComment( comment );
|
|
long unix_time;
|
|
mpArchiveStorageObject->ReadGlLong( unix_time );
|
|
storage_object->mTimeDate.SetTimeDate( unix_time );
|
|
short int packed_attributes;
|
|
mpArchiveStorageObject->ReadGlShort( packed_attributes );
|
|
storage_object->mAttributes.SetFromPackedAttributes( packed_attributes );
|
|
}
|
|
list.mrMonitor.ArchiveOperation( AL_END_DIRECTORY_READ, this, 0 );
|
|
return mStatus;
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALEntryList::ClearError()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Reset the error status for an entry list.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
// #include "glarc.h"
|
|
//
|
|
// void ALGlArchive::PreCreate()
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None, internal support function.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// The Create() function is found in the base class. It takes care of
|
|
// sticking a bunch of compressed objects into an archive. It gets
|
|
// ready to do this, then class this function first.
|
|
//
|
|
// Since this is a virtual function, the derived class can put any
|
|
// specialized behavior here. For Greenleaf archives, the only
|
|
// specialized behavior needed is to save enough space for a long
|
|
// in the file. After the archive is created, the long at offset 0
|
|
// will get a pointer to the start of the directory.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New Release
|
|
//
|
|
|
|
void AL_PROTO
|
|
ALGlArchive::PreCreate() /* Tag protected function */
|
|
{
|
|
//
|
|
// The first four bytes in the archive are a long that points to the
|
|
// first byte of the directory. I don't know where the directory is
|
|
// going to be, so I just reserve space at this time with a dummy value.
|
|
//
|
|
mpArchiveStorageObject->WriteGlLong( 0x12345678L );
|
|
}
|
|
|