//
// COPYD.CPP
//
//  Source file for ArchiveLib 2.0
//
//  Copyright (c) Greenleaf Software, Inc. 1994-1996
//  All Rights Reserved
//
// CONTENTS
//
//   ALCopyDecompressor::operator new()
//   ALCopyDecompressor::ALCopyDecompressor()
//   newALCopyDecompressor()
//   ALCopyDecompressor::~ALCopyDecompressor()
//   ALCopyDecompressor::Decompress()
//   ALCopyDecompressor::Clone()
//
//
// DESCRIPTION
//
//  The source files needed to support the decompressor class
//  ALCopyDecompressor.
//
// REVISION HISTORY
//
//  May 22, 1994  1.0A  : First release
//
//   February 14, 1996  2.0A : New release
//

#include "arclib.h"
#if !defined( AL_IBM )
#pragma hdrstop
#endif

#include "copyengn.h"
#include "_openf.h"

//
// NAME
//
//  ALCopyDecompressor::operator new()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  The memory allocator used with DLL versions of ArchiveLib.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  void * ALCopyDecompressor::operator new( size_t size )
//
// C SYNOPSIS
//
//  None, this is an internal C++ function.
//
// VB SYNOPSIS
//
//  None, this is an internal C++ function.
//
// DELPHI SYNOPSIS
//
//  None, this is an internal C++ function.
//
// ARGUMENTS
//
//  size  :  The amount of storage that needs to be allocated for
//           this object.
//
// DESCRIPTION
//
//  When using the DLL version of ArchiveLib, it is a good idea to
//  allocate the storage for objects from inside the DLL, since they
//  will be freed inside the DLL.  If we don't have the new operator
//  for a class, its storage will be allocated from the EXE before
//  the constructor code is called.  Then, when it is time to free
//  the storage, the delete operator will be called inside the DLL.
//  Not good, right?
//
//  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 storage.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release
//


#if defined( AL_BUILDING_DLL )
void AL_DLL_FAR * AL_PROTO
ALCopyDecompressor::operator new( size_t size )  /* Tag internal function */
{
    return ::new char[ size ];
}
#endif

//
// NAME
//
//  ALCopyDecompressor::ALCopyDecompressor()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++  C  VB  Delphi
//
// SHORT DESCRIPTION
//
//  Default constructor for the copy decompression engine.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  ALCopyDecompressor::ALCopyDecompressor();
//
// C SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  hALDecompressor newALCopyDecompressor();
//
// VB SYNOPSIS
//
//  Declare Function newALCopyDecompressor Lib "AL20LW" () As Long
//
// DELPHI SYNOPSIS
//
//  function newALCopyDecompressor : hALDecompressor;
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  This function creates a new copy decompression engine.  The copy
//  engine is used to do simply binary copies of a compressed
//  object from an archive or other compressed object.  Since no decompression
//  is actually taking place, the copy decompressor is supposed to be fast and
//  efficient.
//
//  Note that under Visual Basic or C, it is up to the user to destroy
//  this engine by calling deleteDecompressor().  C++ users only need to
//  call the destructor explicitly when they have created the object
//  dynamically using the new operator.
//
// RETURNS
//
//  The C++ function returns nothing.  The C and VB functions return the
//  handle of the newly created decompressor.  A value of 0 for this handle
//  means the object could not be properly created.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

AL_PROTO
ALCopyDecompressor::ALCopyDecompressor()  /* Tag public function */
    : ALDecompressor( AL_COMPRESSION_COPY, "Binary copy" )
{
}

#if !defined( AL_NO_C )
extern "C" AL_LINKAGE
hALDecompressor AL_FUNCTION newALCopyDecompressor() /* Tag public function */
{
    return (hALDecompressor) new ALCopyDecompressor();
}
#endif

//
// NAME
//
//  ALCopyDecompressor::~ALCopyDecompressor()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Destructor for the copy decompression engine.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  ALCopyDecompressor::~ALCopyDecompressor();
//
// C SYNOPSIS
//
//  None, see deleteDecompressor().
//
// VB SYNOPSIS
//
//  None, see deleteDecompressor().
//
// DELPHI SYNOPSIS
//
//  None, see deleteDecompressor().
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  The destructor has absolutely nothing to do.  In the debug
//  versions of the library, the dtor checks to be sure that it
//  is operating on the right type of object.
//
//  Note that more often than not, this virtual function will be
//  called using the base class.  In fact, C/VB/Delphi users don't
//  even have a choice about it.
//
// RETURNS
//
//  Nothing.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//  May 22, 1994  1.0A  : First release
//
//   February 14, 1996  2.0A : New release

AL_PROTO
ALCopyDecompressor::~ALCopyDecompressor()  /* Tag public function */
{
    AL_ASSERT( GoodTag(),
               "~ALCopyDecompressor: Attempt to delete invalid object" );
}

//
// NAME
//
//  ALCopyDecompressor::Decompress()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Perform a binary copy of input to output.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  int ALCopyDecompressor::Decompress( ALStorage& input,
//                                      ALStorage& output );
//
// C SYNOPSIS
//
//  None, see the base class function ALDecompress().
//
// VB SYNOPSIS
//
//  None, see the base class function ALDecompress().
//
// DELPHI SYNOPSIS
//
//  None, see the base class function ALDecompress().
//
// ARGUMENTS
//
//  input  : A reference to the input storage object.
//
//  output : A reference to the output storage object.
//
// DESCRIPTION
//
//  This is ostensibly a decompression engine, but really all it does
//  is copy input directly to the output.  The most exciting thing it
//  does during the entire process is initialize CRC checking.
//
//  This function will almost always be called indirectly, by means of
//  a virtual function call off the base class.  That's why you won't
//  see any C, VB, or Delphi functions here.  Those languages will only
//  be able to call the Decompress() routine by way of the base class.
//
// RETURNS
//
//  AL_SUCCESS, or < AL_SUCCESS if something bad happens.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

int AL_PROTO
ALCopyDecompressor::Decompress( ALStorage AL_DLL_FAR & input,  /* Tag public function */
                                ALStorage AL_DLL_FAR & output,
                                long length )
{
    ALOpenFiles files( input, output );
    if ( input.mStatus < AL_SUCCESS )
        return mStatus = input.mStatus;
    if ( output.mStatus < AL_SUCCESS )
        return mStatus = output.mStatus;
    output.InitCrc32();

    int c;
//    if ( length == -1 )
//        return SetError( NEED_LENGTH,
//                           "The copy engine requires a length parameter when "
//                           "decompressing" );
    for ( ; length != 0 ; length-- ) {
        c = input.ReadChar();
        if ( c < 0 )
            break;
        output.WriteChar( c );
    }
    if ( input.mStatus < AL_SUCCESS )
        return mStatus = input.mStatus;
    if ( output.mStatus < AL_SUCCESS )
        return mStatus = output.mStatus;
    return mStatus;
}

//
// NAME
//
//  ALCopyDecompressor::Clone()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Create a copy of an existing decompressor
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//  #include "copyengn.h"
//
//  ALCopyDecompressor::Clone( int engine_type );
//
// C SYNOPSIS
//
//  No C equivalent.
//
// VB SYNOPSIS
//
//  No VB equivalent.
//
// DELPHI SYNOPSIS
//
//  No Delphi equivalent.
//
// ARGUMENTS
//
//  engine_type  :  This argument indicates what sort of engine the
//                  caller wants to create.  A value of either
//                  AL_COMPRESSION_DEFAULT or AL_COMPRESSION_COPY will
//                  cause this function to create a clone.  Any other
//                  value (for example, AL_DEFLATE), will return a 0,
//                  indicating that this object doesn't know how to
//                  perform that sort of decompression.
//
// DESCRIPTION
//
//  Although this is a public function, it isn't really of any use
//  to end users.  Clone() is a virtual function for the base class
//  ALDecompressor, and can be called to create a duplicate of an
//  existing de/compression engine.
//
//  Why is this useful?  It is useful because it allows us to use
//  what is the equivalent of a virtual constructor.  We can pass a
//  pointer to a copy engine to the archiving code, and it can then in
//  turn stuff copies of that engine into an ALEntryList without
//  having any idea what sort of compression engine it is actually creating.
//
// RETURNS
//
//  A copy of a newly created decompression engine.  When this routine is
//  called, it will usually be called via a virtual function from a pointer
//  to a base class object, which means the resulting pointer will be
//  treated as an ALDecompressor * by the code.
//
//  If this routine doesn't know how to create an engine of the correct type,
//  it returns a 0.  When performing decompression from an archive, the
//  extraction code might have to call Clone() for several different engine
//  types until it finally finds an engine that can be cloned.  The combination
//  of different engine types in the toolkit can all be called until a winner
//  is found.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New release

ALDecompressor AL_DLL_FAR * AL_PROTO
ALCopyDecompressor::Clone( int engine_type ) const  /* Tag public function */
{
    switch ( engine_type ) {
        case AL_COMPRESSION_DEFAULT :
        case AL_COMPRESSION_COPY :
            return new ALCopyDecompressor();
    }
    return 0;
}