838 lines
27 KiB
C++
Executable File
838 lines
27 KiB
C++
Executable File
//
|
|
// FILESTOR.CPP
|
|
//
|
|
// Source file for ArchiveLib 1.0
|
|
//
|
|
// Copyright (c) Greenleaf Software, Inc. 1994
|
|
// All Rights Reserved
|
|
//
|
|
// CONTENTS
|
|
//
|
|
// ALFile::operator new()
|
|
// ALFile::ALFile()
|
|
// ALFile::~ALFile()
|
|
// ALFile::LoadBuffer()
|
|
// ALFile::FlushBuffer()
|
|
// ALFile::Seek()
|
|
// ALFile::Open()
|
|
// ALFile::MakeTempName()
|
|
// ALFile::Create()
|
|
// ALFile::Close()
|
|
// ALFile::RenameToBackup()
|
|
// ALFile::Rename()
|
|
// ALFile::UnRename()
|
|
// ALFile::Delete()
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This file contains the C++ member functions to support class
|
|
// ALFile. This class works very closely with the parent class,
|
|
// ALStorage, found in STORAGE.CPP. You will find in many cases
|
|
// the virtual functions found here in the derived class call
|
|
// the same function in the parent class to help out with some
|
|
// of the work.
|
|
// We don't really do anything exciting in the WEP, it is just
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 22, 1994 1.0A : First release
|
|
//
|
|
//
|
|
|
|
#include "arclib.h"
|
|
#pragma hdrstop
|
|
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <time.h>
|
|
//#include <dos.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
|
|
#include "filestor.h"
|
|
|
|
//
|
|
// void * ALFile::operator new( size_t size )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// size : The number of bytes needed to create a new ALFile object.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// A pointer to the newly allocated storage area, or 0 if no storage
|
|
// was available.
|
|
//
|
|
// 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.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
#if defined( AL_BUILDING_DLL )
|
|
void AL_DLL_FAR * AL_PROTO ALFile::operator new( size_t size )
|
|
{
|
|
return ::new char[ size ];
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// ALFile::ALFile( const char *file_name = "",
|
|
// int buffer_size = 4096,
|
|
// ALCase name_case = AL_LOWER)
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// file_name : The initial file name of the ALFile object you are
|
|
// creating. By default, this is a blank string, which
|
|
// will get converted to a temporary name before opening
|
|
// the actual disk file.
|
|
//
|
|
// buffer_size : The size of the object's I/O buffer. The default of 4096
|
|
// should give very good performance.
|
|
//
|
|
// name_case : This parameter determines whether the file names will
|
|
// always be converted to upper case, lower case, or left
|
|
// in mixed case. Under MS-DOS, you shouldn't use mixed
|
|
// case, because the O/S file naming convention is case
|
|
// insensitive. ArchiveLib will think "TEMP.BAK" and
|
|
// "temp.bak" are different, when they really aren't.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing, this is a constructor.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This constructor is used to create a new ALFile object, which will
|
|
// usually be treated as an ALStorage object by ArchiveLib functions.
|
|
// It is important to note that not much happens during construction of
|
|
// this object, the real activity happens after you call the Open()
|
|
// function. Just creating this object *does not* create a file on disk!
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
AL_PROTO ALFile::ALFile( const char AL_DLL_FAR *file_name /* = "" */,
|
|
int buffer_size /* = 4096 */,
|
|
ALCase name_case /* = AL_LOWER */)
|
|
// Note: if non-msdos, change case parameter to AL_MIXED
|
|
: ALStorage( file_name, buffer_size, AL_FILE_OBJECT, name_case ) {
|
|
miHandle = -1;
|
|
}
|
|
|
|
//
|
|
// ALFile::~ALFile()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// The destructor for an ALFile object doesn't have to do much work.
|
|
// The base class destructor will take care of freeing the I/O buffer,
|
|
// and any other loose ends. All we have to do here is make sure
|
|
// the file gets closed, and that its buffers get flushed to the disk
|
|
// file.
|
|
//
|
|
// Note that in debug mode, the destructor also checks this for the
|
|
// correct class type. This helps flag erroneous or duplicated
|
|
// destructor calls.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
AL_PROTO ALFile::~ALFile()
|
|
{
|
|
AL_ASSERT( GoodTag(), "~ALFile: attempting to delete invalid object" );
|
|
if ( miHandle != -1 )
|
|
Close();
|
|
}
|
|
|
|
//
|
|
// int ALFile::LoadBuffer( long address )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// address : The long offset into the physical storage object. A
|
|
// seek/read combination will be executed at this location,
|
|
// so that subsequent calls to read data will start at
|
|
// the given address.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS, AL_SEEK_ERROR, AL_END_OF_FILE, or possibly another
|
|
// error code < AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is used in the library whenever a byte needs to be read
|
|
// that isn't present in the current I/O buffer. It has to use
|
|
// the C RTL function lseek() to go to the correct position in the library.
|
|
// If that works, it uses the C RTL function read() to read in an I/O
|
|
// buffer full of data.
|
|
//
|
|
// After that operation is performed, muReadIndex is set to 0, indicating
|
|
// that the next read from the I/O buffer will take place at location 0.
|
|
// mlFilePointer is set to address plus the number of bytes read, so
|
|
// we know where the next read from the file will take place. And
|
|
// muBufferValidData is set to the count of bytes read in from this
|
|
// location. That lets us know how far we can read in the I/O buffer
|
|
// before we run out of space.
|
|
//
|
|
// Note that if CRC checking has been turned on, we will update the
|
|
// current working CRC value with the new data that has been read
|
|
// in from the buffer.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::LoadBuffer( long address )
|
|
{
|
|
if ( mStatus < AL_SUCCESS )
|
|
return mStatus;
|
|
if ( mlFilePointer != address ) {
|
|
long result = lseek( miHandle, address, SEEK_SET );
|
|
if ( result == -1L )
|
|
return mStatus.SetError( AL_SEEK_ERROR,
|
|
"Seek failure on %s. errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
}
|
|
int result = read( miHandle, mpcBuffer, muBufferSize );
|
|
if ( result == 0 )
|
|
return AL_END_OF_FILE;
|
|
if ( result < 0 )
|
|
return mStatus.SetError( AL_READ_ERROR,
|
|
"Read failure on %s. errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
if ( miUpdateCrcFlag )
|
|
UpdateCrc( result );
|
|
muReadIndex = 0; //Reading can resume at this location in the I/O buffer
|
|
mlFilePointer += result;
|
|
muBufferValidData = result;
|
|
YieldTime();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// int ALFile::FlushBuffer()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// An integer status value, AL_SUCCESS, AL_WRITE_ERROR, or possibly some
|
|
// status code < AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is the counterpart to LoadBuffer(). It gets called
|
|
// when a write operation is poised to overflow the I/O buffer. This
|
|
// means we need to flush the buffer out to disk, then reset some
|
|
// data members.
|
|
//
|
|
// Unlike LoadBuffer(), this function doesn't have an address argument,
|
|
// so we don't have to perform a seek(). Instead, the data will be
|
|
// written out to the current position of the file pointer. If the
|
|
// write is successful, muWriteIndex is set to 0, indicating that the
|
|
// next write to the I/O buffer can go to position 0. mlFilePointer is
|
|
// incremented by the length of the write, so we know where the next read
|
|
// or write will occur. Finally, muBufferValidData is set to 0, indicating
|
|
// that there is no data in the I/O buffer that has been written, and
|
|
// there is no data that can be read.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::FlushBuffer()
|
|
{
|
|
if ( mStatus < 0 )
|
|
return mStatus;
|
|
if ( muWriteIndex != 0 ) {
|
|
if ( miUpdateCrcFlag )
|
|
UpdateCrc( muWriteIndex );
|
|
int result = write( miHandle, mpcBuffer, muWriteIndex );
|
|
muWriteIndex = 0;
|
|
if ( result == -1L )
|
|
return mStatus.SetError( AL_WRITE_ERROR,
|
|
"Write failure on %s. errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
mlFilePointer += result;
|
|
}
|
|
muReadIndex = 0;
|
|
muBufferValidData = 0;
|
|
YieldTime();
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// int ALFile::Seek( long address )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// address : The address in the physical disk to seek to.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS, AL_SEEK_ERROR, or possibly some other status code < AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is a function the user can call to position the read/write pointer
|
|
// to a new location in the disk file. If there is any data that has been
|
|
// written to the I/O buffer, it gets flushed first. After that, we do
|
|
// a seek, and update mlFilePointer to reflect the new reality. Note that
|
|
// the other important data members will have been updated by FlushBuffer().
|
|
//
|
|
// And no, this guy doesn't do a LoadBuffer(). Which is fine if you are
|
|
// going to do a bunch of writes afterwards. If you are going to read data
|
|
// immediately after Seek(), you would have been better of calling
|
|
// LoadBuffer().
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Seek( long address )
|
|
{
|
|
FlushBuffer();
|
|
if ( mStatus < 0 )
|
|
return mStatus;
|
|
if ( mlFilePointer != address ) {
|
|
long result = lseek( miHandle, address, SEEK_SET );
|
|
if ( result == -1L )
|
|
return mStatus.SetError( AL_SEEK_ERROR,
|
|
"Seek failure on %s. errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
}
|
|
mlFilePointer = address;
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// int ALFile::Open()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_CANT_OPEN_FILE, AL_SUCCESS, or possibly some other error code
|
|
// < AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This is an important function, because it converts the ALFile
|
|
// object from a dinky little unimportant object, to a big massive
|
|
// thing that is ready to do serious work.
|
|
//
|
|
// The first thing we do here is see if we can open the file. We try
|
|
// to open it with READ/WRITE privileges, but we give up and drop back
|
|
// to READ only if that doesn't work out.
|
|
//
|
|
// We then call the base class ALStorage::Open() who takes care of
|
|
// allocating buffers and initializing data members.
|
|
//
|
|
// Finally, we have to get the protection attributes and time date
|
|
// stamps for the file. After those are stored off, the file is ready
|
|
// for abuse.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Open()
|
|
{
|
|
if ( mStatus < AL_SUCCESS )
|
|
return mStatus;
|
|
miHandle = open( mName, O_BINARY | O_RDWR );
|
|
if ( miHandle == -1 && errno == EACCES )
|
|
miHandle = open( mName, O_BINARY | O_RDONLY );
|
|
if ( miHandle == -1 )
|
|
return mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"File open failure. Open of %s returned "
|
|
"errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
|
|
ALStorage::Open();
|
|
struct stat buf;
|
|
struct tm *tblock;
|
|
if ( stat( mName, &buf ) == -1 )
|
|
return mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"Couldn't get time, date, and size "
|
|
"information for %s. errno = %d.",
|
|
mName.GetName(),
|
|
errno );
|
|
mlSize = buf.st_size;
|
|
tblock = localtime( &buf.st_mtime );
|
|
mTimeDate.SetTimeDate( tblock );
|
|
#if defined( AL_WIN32S )
|
|
DWORD attributes = GetFileAttributes( mName );
|
|
if ( attributes == 0xFFFFFFFF )
|
|
return mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"Couldn't get Win32 file attribute "
|
|
"information for %s. GetLastError = %d.",
|
|
mName.GetName(),
|
|
GetLastError() );
|
|
mAttributes.SetFromWin32Attributes( attributes );
|
|
#else
|
|
unsigned attributes;
|
|
if ( _dos_getfileattr( mName, &attributes ) != 0 )
|
|
return mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"Couldn't get DOS attribute "
|
|
"information for %s. errno = %d.",
|
|
mName.GetName(),
|
|
errno );
|
|
mAttributes.SetFromDosAttributes( attributes );
|
|
#endif
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// void ALFile::MakeTempName( int i )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// i : A numeric argument that can somehow be incorporated into
|
|
// the temporary file name. Create() will call this function
|
|
// while incrementing this number in an attempt to find a unique
|
|
// name.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Nothing.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is called by Create() and other functions when they
|
|
// decide they need to cook up a temporary file name. The single parameter
|
|
// i is incremented by the calling program so that repeated calls should
|
|
// eventually produce a unique name.
|
|
//
|
|
// All this function does to create that unique name is perform a sprintf()
|
|
// into a buffer using a simple template. The result is copied into the
|
|
// mName member, and is ready to be tried out.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
void AL_PROTO ALFile::MakeTempName( int i )
|
|
{
|
|
char name[ 21 ];
|
|
|
|
sprintf( name, "~al~%03d.tmp", i );
|
|
mName = name;
|
|
}
|
|
|
|
//
|
|
// int ALFile::Create()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS, AL_CANT_OPEN_FILE, or possibly some other error code
|
|
// < AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is used to create a new file storage object. Since
|
|
// we are creating a new object, we must be able to open it with read
|
|
// access. We will also rudely obliterate any existing file.
|
|
//
|
|
// The first thing we do here is call the base class Create() function.
|
|
// It takes care of setting up the I/O buffer and initializing the
|
|
// data members used to support the class.
|
|
//
|
|
// Next, function checks to see if we have a valid filename. If
|
|
// not, a search is made for a valid temporary file name. In either
|
|
// case, the file is then opened with R/W access, in O_CREAT
|
|
// mode, obliterating any existing file with the same name.
|
|
//
|
|
// Once the file is open, everything is ready to go, and you can write
|
|
// to the file at will. Don't expect much to happen if you try to
|
|
// read, however.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Create()
|
|
{
|
|
ALStorage::Create();
|
|
if ( mStatus < AL_SUCCESS )
|
|
return mStatus;
|
|
if ( (char *) mName == 0 || strlen( mName ) == 0 ) {
|
|
for ( int i = 0 ; i < 999 ; i++ ) {
|
|
MakeTempName( i );
|
|
miHandle = open( mName,
|
|
O_CREAT | O_RDWR | O_BINARY | O_EXCL,
|
|
S_IREAD | S_IWRITE );
|
|
if ( miHandle != -1 )
|
|
break;
|
|
else if ( errno != EEXIST && errno != EACCES ) {
|
|
mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"Temporary file creation failure. "
|
|
"Open of %s returned errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
mName = "";
|
|
return AL_CANT_OPEN_FILE;
|
|
}
|
|
}
|
|
if ( i == 1000 ) {
|
|
mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"Temporary file creation failure. "
|
|
"Tried 1000 times to open %s "
|
|
"(or a name something like that).",
|
|
mName.GetName() );
|
|
mName = "";
|
|
return AL_CANT_OPEN_FILE;
|
|
}
|
|
} else {
|
|
miHandle = open( mName,
|
|
O_CREAT | O_RDWR | O_BINARY | O_TRUNC,
|
|
S_IREAD | S_IWRITE );
|
|
}
|
|
if ( miHandle == -1 )
|
|
return mStatus.SetError( AL_CANT_OPEN_FILE,
|
|
"File creation failure. "
|
|
"Open of %s returned errno = %d",
|
|
mName.GetName(),
|
|
errno );
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// int ALFile::Close()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// Any status code, hopefully AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is called when you are done accessing a file, and want
|
|
// to free up its resources. The first thing it does is check to see
|
|
// if the file was ever actually opened. If it was, we flush the output
|
|
// buffer, then calculate and store the file length. Finally, we close
|
|
// the disk file, then call the base class Close() function to clean up
|
|
// the buffers and deal with other miscellaneous dirty work.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Close()
|
|
{
|
|
if ( miHandle == -1 )
|
|
return mStatus;
|
|
FlushBuffer();
|
|
mlSize = filelength( miHandle );
|
|
if ( miCreated && mTimeDate.Valid() ) {
|
|
#if defined( AL_WIN32S )
|
|
// Can you do this under NT? I don't know how.
|
|
#else
|
|
_dos_setftime( miHandle, mTimeDate.GetDosDate(), mTimeDate.GetDosTime() );
|
|
#endif
|
|
}
|
|
close( miHandle );
|
|
miHandle = -1;
|
|
ALStorage::Close();
|
|
if ( miCreated && mTimeDate.Valid() ) {
|
|
#if defined( AL_WIN32S )
|
|
SetFileAttributes( mName, mAttributes.GetWin32Attributes() );
|
|
#else
|
|
_dos_setfileattr( mName, mAttributes.GetDosAttributes() );
|
|
#endif
|
|
}
|
|
return mStatus;
|
|
}
|
|
|
|
//
|
|
// int ALFile::RenameToBackup( int delete_on_clash = 1 )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// delete_on_clash : If this flag is set, it means that we will overwrite
|
|
// an existing file with this file if the names clash.
|
|
// For example, if I am renaming TEMP.DAT to TEMP.BAK,
|
|
// and a TEMP.BAK already exists, I will delete it
|
|
// before renaming if this arg is set.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS or AL_RENAME_ERROR.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is a quick way to rename a storage object. The new
|
|
// name created is the default name, which usually means changing the
|
|
// file extension to ".BAK", from whatever it was.
|
|
//
|
|
// You don't see it here, but both the mName member and the physical file
|
|
// name are both updated. That all happens in the Rename() function.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::RenameToBackup( int delete_on_clash /* = 1 */ )
|
|
{
|
|
mName.ChangeExtension();
|
|
return Rename( 0, delete_on_clash );
|
|
}
|
|
|
|
//
|
|
// int ALFile::Rename( const char *new_name /* = 0 */,
|
|
// int delete_on_clash /* = 1 */ )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// new_name : A character pointer to a new file name. If a name is
|
|
// defined here, the file is renamed to this new value.
|
|
// If this value is 0, it means that we expect that
|
|
// the mName member has already been updated with a
|
|
// new name. In this case, the old name of the
|
|
// file is renamed to the new name.
|
|
//
|
|
// delete_on_clash : If this flag is set, it means that we will overwrite
|
|
// an existing file with this file if the names clash.
|
|
// For example, if I am renaming TEMP.DAT to TEMP.BAK,
|
|
// and a TEMP.BAK already exists, I will delete it
|
|
// before renaming if this arg is set.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS or AL_RENAME_ERROR.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This virtual function provides a way to rename a storage object's
|
|
// physical implementation. It first updates the mName member if a
|
|
// new_name argument is provided. After that, we unlink the clash file
|
|
// if one exists, then do a simple rename of mName.mszOldName to
|
|
// new_name.
|
|
//
|
|
// Note that this function does a lot of error checking in debug mode.
|
|
// It also does a little error checking in release mode.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Rename( const char AL_DLL_FAR *new_name /* = 0 */,
|
|
int delete_on_clash /* = 1 */ )
|
|
{
|
|
AL_ASSERT( miHandle == -1, "Rename: attempting to rename open file" );
|
|
AL_ASSERT( mName.GetName() != 0, "Rename: attempting to rename file with null name" );
|
|
AL_ASSERT( strlen( mName ) > 0, "Rename: attempting to rename file with 0 length name" );
|
|
|
|
int status;
|
|
const char *real_old_name;
|
|
const char *real_new_name;
|
|
if ( new_name ) {
|
|
real_old_name = mName.GetSafeName();
|
|
real_new_name = new_name;
|
|
} else {
|
|
real_old_name = mName.GetSafeOldName();
|
|
real_new_name = mName.GetSafeName();
|
|
}
|
|
#if !defined( AL_WIN32S )
|
|
const char *p = strchr( real_new_name, '.' );
|
|
if ( p && strlen( p ) > 4 )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error trying to rename %s. It has a long "
|
|
"extension, which could lead to inadvertent "
|
|
"deletion of a file when trying to rename.",
|
|
real_old_name );
|
|
#endif
|
|
if ( delete_on_clash ) {
|
|
if ( mName.mCase == AL_MIXED )
|
|
status = strcmp( real_new_name, real_old_name );
|
|
else
|
|
status = stricmp( real_new_name, real_old_name );
|
|
if ( status == 0 )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error attempting to rename %s to %s. "
|
|
"Can't rename to the same name!",
|
|
real_new_name,
|
|
real_old_name );
|
|
status = unlink( real_new_name );
|
|
if ( status != 0 && errno != ENOENT )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error deleting %s before renaming %s. "
|
|
"errno = %d",
|
|
real_new_name,
|
|
real_old_name,
|
|
errno );
|
|
}
|
|
status = rename( real_old_name, real_new_name );
|
|
if ( status != 0 )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error renaming %s to %s. errno = %d",
|
|
real_old_name,
|
|
real_new_name,
|
|
errno );
|
|
if ( new_name != 0 )
|
|
mName = new_name;
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// int ALFile::UnRename( int delete_on_clash /* = 1 */ )
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// delete_on_clash : If this flag is set, it means that we will overwrite
|
|
// an existing file with this file if the names clash.
|
|
// For example, if I am renaming TEMP.BAK to TEMP.DAT,
|
|
// and a TEMP.DAT already exists, I will delete it
|
|
// before renaming if this arg is set.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_SUCCESS or AL_RENAME_ERROR.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This virtual function provides a way to undo a previous renaming of
|
|
// a storage object's physical name. We can do this because the mName
|
|
// member of ALStorage keeps track both of the current name of the file,
|
|
// and the old name. In this case, we just rename the current name to
|
|
// the old name. Then we update the mName member so it is accurate.
|
|
//
|
|
// Note that this function does a lot of error checking in debug mode.
|
|
// It also does a little error checking in release mode.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::UnRename( int delete_on_clash /* = 1 */ )
|
|
{
|
|
AL_ASSERT( miHandle == -1, "UnRename: attempting to rename open file" );
|
|
AL_ASSERT( mName.GetName() != 0, "UnRename: attempting to rename file with null name" );
|
|
AL_ASSERT( mName.GetOldName() != 0, "UnRename: attempting to rename file with null old name" );
|
|
AL_ASSERT( strlen( mName ) > 0, "UnRename: attempting to rename file with 0 length name" );
|
|
AL_ASSERT( strlen( mName.GetOldName() ) > 0, "UnRename: attempting to rename file with 0 length old name" );
|
|
|
|
int status;
|
|
|
|
if ( delete_on_clash ) {
|
|
status = unlink( mName.GetOldName() );
|
|
if ( status != 0 && errno != ENOENT )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error deleting %s before renaming %s. "
|
|
"errno = %d",
|
|
mName.GetOldName(),
|
|
mName.GetName(),
|
|
errno );
|
|
}
|
|
status = rename( mName, mName.GetOldName() );
|
|
if ( status != 0 && errno != ENOENT )
|
|
return mStatus.SetError( AL_RENAME_ERROR,
|
|
"Error renaming %s to %s. errno = %d",
|
|
mName.GetName(),
|
|
mName.GetOldName(),
|
|
errno );
|
|
ALStorage::mName = mName.GetOldName();
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// int ALFile::Delete()
|
|
//
|
|
// ARGUMENTS:
|
|
//
|
|
// None.
|
|
//
|
|
// RETURNS
|
|
//
|
|
// AL_DELETE_ERROR or AL_SUCCESS.
|
|
//
|
|
// DESCRIPTION
|
|
//
|
|
// This function is called to delete the physical object associated with
|
|
// a file. This simply means calling the unlink() function for the
|
|
// given name.
|
|
//
|
|
// REVISION HISTORY
|
|
//
|
|
// May 26, 1994 1.0A : First release
|
|
//
|
|
|
|
int AL_PROTO ALFile::Delete()
|
|
{
|
|
AL_ASSERT( miHandle == -1, "Delete: attempting to delete open file" );
|
|
AL_ASSERT( mName.GetName() != 0, "Delete: attempting to delete file with null name" );
|
|
AL_ASSERT( strlen( mName ) > 0, "Delete: attempting to delete file with 0 length name" );
|
|
|
|
int status = unlink( mName );
|
|
if ( status != 0 )
|
|
return mStatus.SetError( AL_DELETE_ERROR,
|
|
"Error deleting file %s, errno = %d ",
|
|
mName.GetName(),
|
|
errno );
|
|
return AL_SUCCESS;
|
|
}
|
|
|
|
|