//
// OBJNAME.CPP
//
//  Source file for ArchiveLib 2.0
//
//  Copyright (c) Greenleaf Software, Inc. 1994-1996
//  All Rights Reserved
//
// CONTENTS
//
//  ALName::operator new()
//  ALName::operator+()
//  ALName::ALName( const char *, ALCase )
//  ALName::ALName( const ALName & )
//  ALName::operator=( const char * )
//  ALName::operator = ( const ALName & )
//  ALName::~ALName()
//  ALName::ChangeExtension()
//  ALName::ChangeTrailingChar()
//  ALName::GetSafeName()
//  ALName::GetSafeOldName()
//  ALName::operator char *()
//  ALName::StripFileName()
//  ALName::StripPath()
//  ALName::WildCardMatch()
//  ALName::Strcpy()
//
// DESCRIPTION
//
//  This file contains all the source code to support class ALName.
//  Class ALName doesn't really do much outside of ALStorage, where
//  it shows up as the mName data member.  It does make cameo appearances
//  elsewhere, such as in the wild card expansion code, but those
//  are pretty limited.
//
// REVISION HISTORY
//
//  May 26, 1994  1.0A  : First release
//
//  July 7, 1994  1.0B  : Lots of petty stuff to make Sun UNIX happy.
//
//   February 14, 1996  2.0A : New Release
//

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

#include <string.h>
#include <ctype.h>

#include "_match.h"

//
// NAME
//
//  ALName::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"
//
//  void * ALName::operator new( size_t size )
//
// C SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi.
//
// ARGUMENTS
//
//  size  :  The number of bytes that the compiler has decided will be
//           necessary to construct a new ALName 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.
//
// RETURNS
//
//  A pointer to some memory that should have been pulled out of the
//  heap for the DLL.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   May 24, 1994  1.0A  : First release
//
//   February 14, 1996  2.0A : New Release
//

#if defined( AL_BUILDING_DLL )

void AL_DLL_FAR * AL_PROTO
ALName::operator new( size_t size )  /* Tag protected function */
{
    return ::new char[ size ];
}

#endif

//
// NAME
//
//  ALName::operator+()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Add a C-style string to an ALName object.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName ALName::operator+( const char *rhs )
//
// C SYNOPSIS
//
//  None, ALName isn't supported for C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, ALName isn't supported for C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, ALName isn't supported for C/VB/Delphi.
//
// ARGUMENTS
//
//  rhs  : The character pointer that is going to be added to the
//         ALName object.  This will often be the string component
//         of another ALName object, cast to type const char *.
//
// DESCRIPTION
//
//  This is one of those C++ functions that makes converts out of C
//  programmers.  It allows me to add two strings together to create
//  a third.  I really like that.
//
//  The implementation is pretty easy.  I allocate a new character buffer of
//  the correct length, then copy the two strings into it.  I use this
//  result as the initializer for a new ALName object, and return that.
//
//  Note that the new string will have the same case sensitivity as 'this'.
//
// RETURNS
//
//  A newly created ALName object.  This disappears quickly, but can
//  be copied into a result object using either the assignment operator
//  or the copy constructor.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_PROTO
ALName::operator+( const char AL_DLL_FAR *rhs )  /* Tag public function */
{
    int l1 = ( rhs ) ? strlen( rhs ) : 0;
    int l2 = ( mszName ) ? strlen( mszName ) : 0;
    char *p = new char[ l1 + l2 + 1 ];
    if ( p ) {
        strcpy( p, mszName );
        if ( rhs )
            strcat( p, rhs );
    }
    ALName result( p, mCase );
    if ( p )
        delete[] p;
    return result;
}


//
// NAME
//
//  ALName::ALName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Construct an ALName object from a C-style string.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName::ALName( const char *s = "",  ALCase name_case = AL_MIXED );
//
// C SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// VB SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// ARGUMENTS
//
//  s        : The initial string value of the new object.  Note that
//             you can pass a null pointer here and all will still be okay.
//
//  name_case: The case sensitivity of the new ALName object.  Will its
//             contents be mixed, or will it always be forced to upper
//             or lower?
//
// DESCRIPTION
//
//  This constructor first initializes the mCase member in an initializer.
//  mCase is a const member, which is nice, because you can make it public.
//  But, it means you can't initialize it *in* the constructor, you have
//  to do it before the body.
//
//  Things are pretty easy after that.  We allocate enough space to hold
//  the initializer string and copy it in.  The old name gets set to 0, since
//  this name hasn't been around long enough to have been renamed.
//  And that's it.
//
// RETURNS
//
//  Nothing.
//
// EXAMPLE
//
//  This function is only used as part of
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

AL_PROTO
ALName::ALName( const char AL_DLL_FAR *s /* = "" */,  /* Tag public function */
                ALCase name_case /* = AL_MIXED */ )
     : mCase( name_case )
{
    mszName = new AL_DLL_FAR char[ strlen( s ) + 1 ];
    if ( mszName )
        Strcpy( s );
     mszOldName = 0;
}

//
// NAME
//
//  ALName::ALName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  The ALName copy constructor.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName::ALName( const ALName &rhs );
//
// C SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// ARGUMENTS
//
//  rhs   :  A reference to another ALName object.  This is the ALName
//           we are going to copy.
//
// DESCRIPTION
//
//  This is the copy constructor.  It is very nearly the same as the
//  other constructor.
//
//  This constructor first initializes the mCase member in an initializer.
//  mCase is a const member, which is nice, because you can make it public.
//  But, it means you can't initialize it *in* the constructor, you have
//  to do it before the body.
//
//  Things are pretty easy after that.  We allocate enough space to hold
//  a copy of the string in the rhs, and then copy it.  The old name gets
//  set to 0, since this name hasn't been around long enough to have been
//  renamed.  We could have copied the old name from the rhs, but I think
//  this way makes more sense.
//  And that's it.
//
// RETURNS
//
//  Nothing.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

AL_PROTO
ALName::ALName( const ALName AL_DLL_FAR &rhs )  /* Tag public function */
     : mCase( rhs.mCase )
{
     const char AL_DLL_FAR *s = rhs.GetSafeName();
     mszName = new AL_DLL_FAR char[ strlen( s ) + 1 ];
     if ( mszName )
          Strcpy( s );
     mszOldName = 0;
}

//
// NAME
//
//  ALName::operator=()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  ALName assignment operator, from C-style string.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName & ALName::operator=( const char * rhs );
//
// C SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi libraries.
//
// VB SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi libraries.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not exported to C/VB/Delphi libraries.
//
// ARGUMENTS
//
//  rhs  :  This is the character string that we are going to assign to this.
//
// DESCRIPTION
//
//  This function performs roughly the same function as the first
//  constructor, but there is a twist.  When we assign a new name to
//  an ALName object, we also make a copy of the previous value and place
//  it in the old name data member.
//
// RETURNS
//
//  A reference to 'this'.  We need to do it that way so we can do:
//
//    a = b = c = "test";
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_DLL_FAR & AL_PROTO
ALName::operator=( const char AL_DLL_FAR * rhs )  /* Tag public function */
{
    if ( rhs == 0 )
        rhs = "";
    if ( rhs == mszName ) // Pathological?
        return *this;

    char AL_DLL_FAR *new_name = new AL_DLL_FAR char[ strlen( rhs ) + 1 ];
    if ( new_name ) {
        if ( mszOldName )
            delete[] mszOldName;
        mszOldName = mszName;
        mszName = new_name;
        Strcpy( rhs );
    } else {
        if ( mszOldName )
            delete[] mszOldName;
        mszOldName = mszName;
        mszName = 0;
    }
    return *this;
}

//
// NAME
//
//  ALName::operator=()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Assignment operator, from ALName object.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName & ALName::operator=( const ALName & rhs )
//
// C SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi.
//
// ARGUMENTS
//
//  rhs   :  The right hand side of the assignment operator.
//
// DESCRIPTION
//
//  This function is very similar to the copy constructor, but it has
//  one additional twist.  When we copy the rhs string value into our
//  string, we move our old name into the backup copy member,
//  mszOldName.  That way, if we change our mind, we can easily
//  switch back to the old name.
//
// RETURNS
//
//  A reference to 'this'.  Like in the above function, we do this so
//  that you can stack assignments:
//
//      a = b = c = "Dummy";
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_DLL_FAR & AL_PROTO
ALName::operator=( const ALName AL_DLL_FAR & rhs )  /* Tag public function */
{
    return *this = rhs.GetName();
}

//
// NAME
//
//  ALName::~ALName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  The ALName destructor.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName::~ALName()
//
// C SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// VB SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// ARGUMENTS
//
//  None, dtor takes on args.
//
// DESCRIPTION
//
//  All this destructor has to do is free up the two pieces of
//  dynamic memory.  I just can't get out of that old C habit of
//  checking a pointer for NULL before deleting it.
//
//  In debug mode, I check the state of this before and after freeing
//  the dynamically allocated memory, in hopes of catching any
//  heap errors near their source.
//
// RETURNS
//
//  None, dtor returns nothing.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

AL_PROTO
ALName::~ALName()  /* Tag public function */
{
    AL_ASSERT( GoodTag(), "~ALName: attempt to delete invalid object" );
    if ( mszName )
        delete[] mszName;
    if ( mszOldName )
        delete[] mszOldName;
    AL_ASSERT( GoodTag(), "~ALName: attempt to delete invalid object" );
}

//
// NAME
//
//  ALName::ChangeExtension()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Change the extension of what is presumably a file name.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName& ALName::ChangeExtension( const char *new_extension = ".bak" );
//
// C SYNOPSIS
//
//  None, ALName isn't available to C/VB/Delphi dudes.
//
// VB SYNOPSIS
//
//  None, ALName isn't available to C/VB/Delphi dudes.
//
// DELPHI SYNOPSIS
//
//  None, ALName isn't available to C/VB/Delphi dudes.
//
// ARGUMENTS
//
//  new_extension  :  The new extension you want to apply to the name.
//
// DESCRIPTION
//
//  This function is used to change the extension of a filename stored
//  in an ALName object.  A lot of times you will want to do this
//  in order to create a backup.  For example, you could change
//  TEMP.DAT to TEMP.BAK.
//
//  This function makes a copy of the current name in mszOldName, so we
//  can keep track of it later.  It then searches for the '.' character
//  in the new file name, and sticks the new extension there.
//
//  If you apply this function to a filename, you can then rename the file
//  by calling ALStorage::Rename() with no argument.  When you do this,
//  the rename function uses the saved OldName and current name as its
//  arguments for the rename() function.
//
// RETURNS
//
//  A reference to 'this'.  This is nice, because it lets you do things
//  like this:
//
//     fopen( name.ChangeExtension( ".OBJ" ), "rb" );
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//
// I need to fix this code up to handle extensions with and without a
// leading '.' character.  Maybe you can use a leading character
// other than '.' to indicate a different type of extension?
//

ALName AL_DLL_FAR & AL_PROTO
ALName::ChangeExtension( const char AL_DLL_FAR *new_extension /* = ".bak" */ )  /* Tag public function */
{
    AL_ASSERT( new_extension != 0, "ChangeExtension: new extension is null" );
    AL_ASSERT( mszName, "ChangeExtension: current name is null" );

    char *file_name = new char[ strlen( mszName ) + strlen( new_extension ) + 1 ];
    if ( mszOldName )
        delete[] mszOldName;
    mszOldName = mszName;
    mszName = file_name;

    if ( !file_name )
        return *this;
    strcpy( mszName, mszOldName );
    char *p = strrchr( file_name, '.' );
    if ( p )
        strcpy( p, new_extension );
    else
        strcat( mszName, new_extension );
    switch ( mCase ) {
        case AL_UPPER : strupr( mszName ); break;
        case AL_LOWER : strlwr( mszName ); break;
        default       : break;
    }
    return *this;
}

//
// NAME
//
//  ALName::ChangeTrailingChar()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Change the final character in what is presumably a file name.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName& ALName::ChangeTrailingChar( char new_char = '@' );
//
// C SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// VB SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible to C/VB/Delphi programmers.
//
// ARGUMENTS
//
//  new_char  :  The new character to use as the last name of the file
//               name.
//
// DESCRIPTION
//
//  This function is used to change the the last character of the extension
//  in filename stored in an ALName object.  A lot of times you will want to
//  do this in order to create a backup.  For example, you could change
//  TEMP.DAT to TEMP.DA@.
//
//  This function makes a copy of the current name in mszOldName, so we
//  can keep track of it later.  It then searches for the end of the
//  current file name, and changes it.
//
//  Note that if the filename doesn't have an extension, we do something
//  funny.  Instead of just changing the last character, we create a 
//  new extension, and append that instead.  So if the filename is
//  "TEST", the new name will be "TEST.@".
//
//  If you apply this function to a filename, you can then rename the file
//  by calling ALStorage::Rename() with no argument.  When you do this, 
//  the rename function uses the saved OldName and current name as its
//  arguments for the rename() function.
//
// RETURNS
//
//  A reference to this.  This is nice, because it lets you do things
//  like this:
//
//     fopen( name.ChangeTrailingChar(), "rb" );
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_DLL_FAR & AL_PROTO
ALName::ChangeTrailingChar( char new_char /* = '@' */ )  /* Tag public function */
{
    AL_ASSERT( mszName != 0, "ChangeTrailingChar: current name is null" );

    char *file_name = new char[ strlen( mszName ) + 2 ];
    if ( mszOldName )
        delete[] mszOldName;
    mszOldName = mszName;
    mszName = file_name;
    switch ( mCase ) {
        case AL_UPPER : new_char = (char) toupper( new_char ); break;
        case AL_LOWER : new_char = (char) tolower( new_char ); break;
        default       : break;
    }
    if ( !file_name )
        return *this;
    strcpy( mszName, mszOldName );
    char *p;
    if ( ( p = strrchr( mszName, '.' ) ) != 0 ) {
        if ( p[ 1 ] == '0' ) {
            p[ 1 ] = new_char;
            p[ 2 ] = '\0';
        } else
            mszName[ strlen( mszName ) - 1 ] = new_char;
    } else {
        char new_extension[ 3 ];
        new_extension[ 0 ] ='.';
        new_extension[ 1 ] = new_char;
        new_extension[ 2 ] = 0;
        strcat( mszName, new_extension );
    }
    return *this;
}

//
// NAME
//
//  ALName::GetSafeName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Get a C-style string pointer that won't be NULL.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  const char * ALName::GetSafeName() const
//
// C SYNOPSIS
//
//  None, ALName is not visible outside of C++.
//
// VB SYNOPSIS
//
//  None, ALName is not visible outside of C++.
//
// DELPHI SYNOPSIS
//
//  None, ALName is not visible outside of C++.
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  This function is used anywhere you want to retrieve the contents of
//  the ALName object using a C-style pointer.  Since the value of
//  mszName can be NULL from time to time, you might have problems.
//  This function fixes that by guaranteeing it won't return a NULL.
//  If the value of mszName is NULL, this function instead returns a
//  pointer to a legitimate empty string.
//
// RETURNS
//
//  This function normally returns the value of mszName.  However, if
//  mszName is currently a null pointer, we return a pointer to an
//  empty string instead.  This means you can use the return value from
//  this function anywhere you want without checking for its NULLity.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

const char AL_DLL_FAR * AL_PROTO
ALName::GetSafeName() const  /* Tag public function */
{
    if ( mszName )
        return mszName;
    else
        return "";
}

//
// NAME
//
//  ALName::GetSafeOldName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Get a C-style char * to the old name, guaranteed non-NULL.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  const char * ALName::GetSafeOldName() const
//
// C SYNOPSIS
//
//  None, ALName not supported for C/VB/Delphi users.
//
// VB SYNOPSIS
//
//  None, ALName not supported for C/VB/Delphi users.
//
// DELPHI SYNOPSIS
//
//  None, ALName not supported for C/VB/Delphi users.
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  This function is used anywhere you want to print the contents of
//  the old name in the ALName object using a C-style pointer.  Since
//  the value of mszOldName can be NULL from time to time, you might have
//  problems. This function fixes that by guaranteeing it won't return a NULL.
//  If the value of mszOldName is NULL, this function instead returns a
//  pointer to a legitimate empty string.
//
// RETURNS
//
//  This function normally returns the value of mszOldName.  However, if
//  mszOldName is currently a null pointer, we return a pointer to an
//  empty string instead.  This means you can use the return value from
//  this function anywhere you want without checking for its NULLity.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

const char AL_DLL_FAR * AL_PROTO
ALName::GetSafeOldName() const  /* Tag public function */
{
    if ( mszOldName )
        return mszOldName;
    else
        return "";
}

//
// NAME
//
//  ALName::operator char *()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Cast an ALName to a char *.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName::operator char *()  const
//
// C SYNOPSIS
//
//  None, ALName is not available outside C++;
//
// VB SYNOPSIS
//
//  None, ALName is not available outside C++;
//
// DELPHI SYNOPSIS
//
//  None, ALName is not available outside C++;
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  This is the casting operator that pretty much lets me use
//  an ALName object anywhere I use a char *.  There are some strange
//  Microsoft compiler problems that make me use this goofy STRINGF
//  typedef instead of char *, but it all adds up the same in
//  the wash.
//
// RETURNS
//
//  A pointer to the string inside the object.  If the string is
//  presently a null pointer, we return a pointer to an empty string
//  instead.  See ALName::GetSafeName() for an explanation of why
//  this is.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

#if defined( AL_MICROSOFT ) && ( AL_MICROSOFT < 800 ) && defined( AL_BUILDING_DLL ) //??????
AL_PROTO
ALName::operator char *()  const  /* Tag public function */
#else
AL_PROTO ALName::operator const STRINGF() const
#endif
{
    if ( mszName )
        return mszName;
    else
        return "";
}

//
// NAME
//
//  ALName::StripFileName()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Strip the file name from an ALName, leaving just the path info.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName& ALName::StripFileName()
//
// C SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  In the wildcard parsing code, sometimes I need to get the path
//  of a file, which means stripping off the filename and extension.
//  This is pretty easy to do, I just find the right spot and stick
//  a string termination character in that position.
//
// RETURNS
//
//  A reference to this.  This is nice, because you can strip the
//  file name from an object and use it in the same operation.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_DLL_FAR & AL_PROTO
ALName::StripFileName()  /* Tag public function */
{
    if ( mszName ) {
        char *p = strrchr( mszName, '\\' );
        if ( p == 0 )
            p = strrchr( mszName, ':' );
        if ( p )
            p[ 1 ] = '\0';
        else
            mszName[ 0 ] = '\0';
    }
    return *this;
}

//
// NAME
//
//  ALName::StripPath()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Strip the path component from an ALName, leaving just the file name.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  ALName& ALName::StripPath()
//
// C SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, can't use ALName from C/VB/Delphi.
//
// ARGUMENTS
//
//  None.
//
// DESCRIPTION
//
//  In the wildcard parsing code, sometimes I need to get the naked
//  file name file, which means stripping off the path and drive stuff.
//  This function does just that.
//
// RETURNS
//
//  A reference to this.  This is nice, because you can strip the
//  path from an object and use it in the same operation.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

ALName AL_DLL_FAR & AL_PROTO
ALName::StripPath()  /* Tag public function */
{
    if ( mszName ) {
#ifdef AL_UNIX
        char *p = strrchr( mszName, '/' );
#else
        char *p = strrchr( mszName, '\\' );
#endif
        if ( p == 0 )
            p = strrchr( mszName, ':' );
        if ( p ) {
            p++;
            char *s = mszName;
            while( ( *s++ = *p++ ) != 0 )
                ;
            *s = '\0';
        } //If not p, path is already stripped
    }
    return *this;
}

//
// NAME
//
//  ALName::WildCardMatch()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Test a name for a match against a wild card pattern.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  int ALName::WildCardMatch( const char *pattern );
//
// C SYNOPSIS
//
//  None, ALName isn't exported to C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, ALName isn't exported to C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, ALName isn't exported to C/VB/Delphi.
//
// ARGUMENTS
//
//  pattern : A pointer to a regular expression, including wildcards
//            and sets.  It can get pretty complicated.
//
// DESCRIPTION
//
//  This is a super-duper powerful function.  It is used to compare
//  a regular expression to the contents of an ALName.  The real meat
//  here is in the public domain string matching code found in _MATCH.CPP.
//
//  The tricky bit here is that we have to make a comparison based
//  on the case sensitivity of this.  Rather than trying to modify
//  the code in _MATCH.CPP, I just make a new copy of the pattern, and
//  mangle the case according to what this expects.
//
// RETURNS
//
//  0 if the pattern doesn't match the object name, 1 if it does.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

int AL_PROTO
ALName::WildCardMatch( const char AL_DLL_FAR *pattern )  /* Tag public function */
{
    int error;
    int result;
    char *p = new char[ strlen( pattern ) + 1 ];

    if ( !p )
        return 0;
    strcpy( p, pattern );
    switch ( mCase ) {
        case AL_UPPER : strupr( p ); break;
        case AL_LOWER : strlwr( p ); break;
        default       : break;
    }
    if ( !is_valid_pattern( p, &error ) )
        result = 0;
    else if ( matche( p, mszName ) == MATCH_VALID )
        result = 1;
    else
        result = 0;
    delete p;
    return result;
}

//
// NAME
//
//  ALName::Strcpy()
//
// PLATFORMS/ENVIRONMENTS
//
//  Console  Windows  PM
//  C++
//
// SHORT DESCRIPTION
//
//  Copy a string while obeying upper/lower case characteristics.
//
// C++ SYNOPSIS
//
//  #include "arclib.h"
//
//  void ALName::Strcpy( const char *s );
//
// C SYNOPSIS
//
//  None, can't use ALName in C/VB/Delphi.
//
// VB SYNOPSIS
//
//  None, can't use ALName in C/VB/Delphi.
//
// DELPHI SYNOPSIS
//
//  None, can't use ALName in C/VB/Delphi.
//
// ARGUMENTS
//
//  s  :  A C-style character string to be copied into mszName.
//
// DESCRIPTION
//
//  Whenever I am going to copy a string into mszName, I need to convert
//  it to the case that this object expects.  If it is AL_UPPER or
//  AL_LOWER, that means copying and then converting to either all upper
//  case or all lower case.  I do that here.
//
// RETURNS
//
//  None.
//
// EXAMPLE
//
// SEE ALSO
//
// REVISION HISTORY
//
//   February 14, 1996  2.0A : New Release
//

void AL_PROTO
ALName::Strcpy( const char AL_DLL_FAR *s )  /* Tag protected function */
{
    strcpy( mszName, s );
     switch ( mCase ) {
        case AL_UPPER : strupr( mszName ); break;
        case AL_LOWER : strlwr( mszName ); break;
        default       : break;
     }
}