360 lines
9.0 KiB
C++
Executable File
360 lines
9.0 KiB
C++
Executable File
//
|
|
// DECOMPRS.CPP
|
|
//
|
|
// Source file for ArchiveLib 2.0
|
|
//
|
|
// Copyright (c) Greenleaf Software, Inc. 1994-1996
|
|
// All Rights Reserved
|
|
//
|
|
// CONTENTS
|
|
//
|
|
// ALDecompressor::operator new()
|
|
// ALDecompressor::ALDecompressor()
|
|
// ALDecompressor::~ALDecompressor()
|
|
// deleteALDecompressor()
|
|
// ALDecompress()
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This file contains functions from the base class of ALDecompressor.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// February 14, 1996 2.0A : New release
|
|
//
|
|
|
|
#include "arclib.h"
|
|
#if !defined( AL_IBM )
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALDecompressor::operator new()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Windows
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Memory allocation operator needed with DLL.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// void * ALDecompressor::operator new( size_t size )
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// size : The number of bytes needed to create a new ALDecompressor object.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// When using a DLL, it is easy to create 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.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A pointer to the newly allocated storage area, or 0 if no storage
|
|
// was available.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// None.
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 23, 1994 1.0A : First release
|
|
//
|
|
// February 14, 1996 2.0A : New release
|
|
//
|
|
|
|
#if defined( AL_BUILDING_DLL )
|
|
|
|
void AL_DLL_FAR * AL_PROTO
|
|
ALDecompressor::operator new( size_t size ) /* Tag internal function */
|
|
{
|
|
return ::new char[ size ];
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALDeompressor::ALDecompressor()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Construct a decompressor object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALDecompressor::ALDecompressor( ALCompressionType compression_type_int,
|
|
// const char *compression_type_string );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// None.
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// compression_type_int : An integer used to indicate the compression
|
|
// type. This needs to be selected from the
|
|
// enumerated type defined in ALDEFS.H. This
|
|
// value is usually what gets stored in an
|
|
// archive to indicate what compression type was
|
|
// used.
|
|
//
|
|
// compression_type_string : A pointer to a C-style string describing the
|
|
// type of compression. This isn't used in
|
|
// any algorithms, it's on hand as a U/I aid.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is the base class constructor for Decompressor objects. Since this
|
|
// class has a pure virtual function, you aren't going to be able to
|
|
// call this guy directly. Instead, it is called from the constructor
|
|
// for guys such as ALGlDecompressor and ALPkDecompressor.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// November 13, 1995 2.00A : First release.
|
|
//
|
|
// February 14, 1996 2.0A : New release
|
|
|
|
|
|
AL_PROTO
|
|
ALDecompressor::ALDecompressor( ALCompressionType compression_type_int, /* Tag public function */
|
|
const char AL_DLL_FAR *compression_type_string )
|
|
: ALEngine( compression_type_int, compression_type_string )
|
|
{
|
|
}
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALDecompressor::~ALDecompressor()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++ C VB Delphi
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// The ALDecompressor destructor.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// ALDecompressor::~ALDecompressor();
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// void deleteALDecompressor( hALDecompressor this_object );
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// Declare Sub deleteALDecompressor Lib "AL20LW" (ByVal this_object&)
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// procedure deleteALDecompressor( this_object : hALDecompressor );
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// None.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This destructor will be called as the derived class is destroyed, such
|
|
// as ALPkDecompressor or ALGlDecompressor. It doesn't have to do anything,
|
|
// so conceivably this function could just be eliminated, and we could use
|
|
// the compiler-generated one. But, I guess we just don't like to leave
|
|
// anything up to chance.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// November 13, 1995 2.00A : First release.
|
|
//
|
|
// February 14, 1996 2.0A : New release
|
|
|
|
AL_PROTO
|
|
ALDecompressor::~ALDecompressor() /* Tag public function */
|
|
{
|
|
}
|
|
|
|
#if !defined( AL_NO_C )
|
|
|
|
extern "C" AL_LINKAGE void AL_FUNCTION
|
|
deleteALDecompressor( hALDecompressor this_object ) /* Tag public function */
|
|
{
|
|
AL_ASSERT_OBJECT( this_object, ALDecompressor, "deleteALDecompressor()" );
|
|
delete (ALDecompressor *) this_object;
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// NAME
|
|
//
|
|
// ALDecompressor::Decompress()
|
|
//
|
|
// PLATFORMS/ENVIRONMENTS
|
|
//
|
|
// Console Windows PM
|
|
// C++ C VB Delphi
|
|
//
|
|
// SHORT DESCRIPTION
|
|
//
|
|
// Decompress from an input object to an output object.
|
|
//
|
|
// C++ SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// int ALDecompressor::Decompress( ALStorage &input_object,
|
|
// ALStorage &output_object );
|
|
//
|
|
// C SYNOPSIS
|
|
//
|
|
// #include "arclib.h"
|
|
//
|
|
// int ALDecompress( hALDecompressor this_object,
|
|
// hALStorage input,
|
|
// hALStorage output );
|
|
//
|
|
// VB SYNOPSIS
|
|
//
|
|
// Declare Function ALDecompress Lib "AL20LW"
|
|
// (ByVal this_object&, ByVal input&, ByVal output& ) As Integer
|
|
//
|
|
// DELPHI SYNOPSIS
|
|
//
|
|
// function ALDecompress( this_object : hALDecompressor;
|
|
// input : hALStorage;
|
|
// output : hALStorage ) : Integer;
|
|
//
|
|
// ARGUMENTS
|
|
//
|
|
// this_object : A reference or pointer to the ALDecompressor object that
|
|
// is going to perform the decompression. Note that the C++
|
|
// version of this call doesn't have an explicit argument
|
|
// here, since it has access to 'this' implicitly.
|
|
//
|
|
// input : A pointer or reference to the input storage object
|
|
// that is going to be decompressed.
|
|
//
|
|
// output : A pointer or reference to the output object that is
|
|
// going to receive the decompressed data.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// An ALDecompressor object only knows how to do one thing, and that is
|
|
// expressed by way of this function. Decompress() takes an input file,
|
|
// and reads until it hits an EOF. Output bytes are written to the
|
|
// output object in plaintext. The exact format of the input is determined
|
|
// by the derived class. ALDecompressor is an abstract base class that
|
|
// can't be instantiated by itself.
|
|
//
|
|
// Since the class can't be instantiated by itself, it's kind of bogus
|
|
// to even suggest that ALDecompressor::Decompress() is a separate function,
|
|
// as I have done here. In reality, the only thing that really exists
|
|
// here is a C function that can be used to call the virtual function
|
|
// set up by a derived class.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A success or failure code. Hopefully AL_SUCCESS, but values less
|
|
// than 0 are possible (as errors.)
|
|
//
|
|
// EXAMPLE
|
|
//
|
|
// SEE ALSO
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// November 13, 1995 2.00A : First release.
|
|
//
|
|
// February 14, 1996 2.0A : New release
|
|
|
|
#if !defined( AL_NO_C )
|
|
extern "C" AL_LINKAGE int AL_FUNCTION
|
|
ALDecompress( hALDecompressor this_object, /* Tag public function */
|
|
hALStorage input,
|
|
hALStorage output,
|
|
long compressed_length )
|
|
{
|
|
AL_ASSERT_OBJECT( this_object, ALDecompressor, "ALDecompress" );
|
|
AL_ASSERT_OBJECT( input, ALStorage, "ALDecompress" );
|
|
AL_ASSERT_OBJECT( output, ALStorage, "ALDecompress" );
|
|
return ( (ALDecompressor *) this_object )->Decompress( *(ALStorage *) input, *(ALStorage *) output, compressed_length );
|
|
}
|
|
#endif
|
|
|