gecko-dev/xpcom/io/nsLocalFileMac.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is Mozilla Communicator client code, 
 * released March 31, 1998. 
 *
 * The Initial Developer of the Original Code is Netscape Communications 
 * Corporation.  Portions created by Netscape are
 * Copyright (C) 1998-1999 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s): 
 *     Steve Dagley <sdagley@netscape.com>
 *     John R. McMullen
 */


#include "nsCOMPtr.h"
#include "nsMemory.h"
#include "nsXPIDLString.h" 

#include "nsLocalFileMac.h"
#include "nsISimpleEnumerator.h"
#include "nsIComponentManager.h"
#include "nsIInternetConfigService.h"
#include "nsIMIMEInfo.h"
#include "prtypes.h"
#include "prerror.h"
#include "nsEscape.h"

#include "nsReadableUtils.h"
#include "nsITimelineService.h"

#ifdef XP_MACOSX
#include "nsXPIDLString.h"

#include "private/pprio.h"
#else
#include "pprio.h" // Include this rather than prio.h so we get def of PR_ImportFile
#endif
#include "prmem.h"
#include "plbase64.h"

#include "FullPath.h"
#include "FileCopy.h"
#include "MoreFilesExtras.h"
#include "DirectoryCopy.h"
#include <Script.h>
#include <Processes.h>
#include <StringCompare.h>

#include <AppleEvents.h>
#include <AEDataModel.h>
#include <AERegistry.h>
#include <Gestalt.h>
#include <UnicodeConverter.h>

#include <Math64.h>
#include <Aliases.h>
#include <Folders.h>
#include <Gestalt.h>
#include "macDirectoryCopy.h"

#include <limits.h>

// Stupid @#$% header looks like its got extern mojo but it doesn't really
extern "C"
{
#ifndef XP_MACOSX
// BADPINK - this MSL header doesn't exist under macosx :-(
#include <FSp_fopen.h>
#endif
}

#if TARGET_CARBON
#include <CodeFragments.h>  // Needed for definition of kUnresolvedCFragSymbolAddress
#include <LaunchServices.h>
#endif

#pragma mark [Constants]

const OSType kDefaultCreator = 'MOSS';

#pragma mark [static util funcs]

static inline void ClearFSSpec(FSSpec& aSpec)
{
    aSpec.vRefNum = 0;
    aSpec.parID = 0;
    aSpec.name[0] = 0;
}


// Simple func to map Mac OS errors into nsresults
static nsresult MacErrorMapper(OSErr inErr)
{
    nsresult outErr;
    
    switch (inErr)
    {
        case noErr:
            outErr = NS_OK;
            break;

        case fnfErr:
            outErr = NS_ERROR_FILE_NOT_FOUND;
            break;

        case dupFNErr:
            outErr = NS_ERROR_FILE_ALREADY_EXISTS;
            break;
        
        case dskFulErr:
            outErr = NS_ERROR_FILE_DISK_FULL;
            break;
        
        case fLckdErr:
            outErr = NS_ERROR_FILE_IS_LOCKED;
            break;
        
        // Can't find good map for some
        case bdNamErr:
            outErr = NS_ERROR_FAILURE;
            break;

        default:    
            outErr = NS_ERROR_FAILURE;
            break;
    }
    return outErr;
}



/*----------------------------------------------------------------------------
    IsEqualFSSpec 
    
    Compare two canonical FSSpec records.
            
    Entry:  file1 = pointer to first FSSpec record.
            file2 = pointer to second FSSpec record.
    
    Exit:   function result = true if the FSSpec records are equal.
----------------------------------------------------------------------------*/

static PRBool IsEqualFSSpec(const FSSpec& file1, const FSSpec& file2)
{
    return
        file1.vRefNum == file2.vRefNum &&
        file1.parID == file2.parID &&
        EqualString(file1.name, file2.name, false, true);
}


/*----------------------------------------------------------------------------
    GetParentFolderSpec
    
    Given an FSSpec to a (possibly non-existent) file, get an FSSpec for its
    parent directory.
    
----------------------------------------------------------------------------*/

static OSErr GetParentFolderSpec(const FSSpec& fileSpec, FSSpec& parentDirSpec)
{
    CInfoPBRec  pBlock = {0};
    OSErr       err = noErr;
    
    parentDirSpec.name[0] = 0;
    
    pBlock.dirInfo.ioVRefNum = fileSpec.vRefNum;
    pBlock.dirInfo.ioDrDirID = fileSpec.parID;
    pBlock.dirInfo.ioNamePtr = (StringPtr)parentDirSpec.name;
    pBlock.dirInfo.ioFDirIndex = -1;        //get info on parID
    err = PBGetCatInfoSync(&pBlock);
    if (err != noErr) return err;
    
    parentDirSpec.vRefNum = fileSpec.vRefNum;
    parentDirSpec.parID = pBlock.dirInfo.ioDrParID;
    
    return err;
}


/*----------------------------------------------------------------------------
    VolHasDesktopDB 
    
    Check to see if a volume supports the new desktop database.
    
    Entry:  vRefNum = vol ref num of volumn
            
    Exit:   function result = error code.
            *hasDesktop = true if volume has the new desktop database.
----------------------------------------------------------------------------*/

static OSErr VolHasDesktopDB (short vRefNum, Boolean *hasDesktop)
{
    HParamBlockRec      pb;
    GetVolParmsInfoBuffer   info;
    OSErr               err = noErr;
    
    pb.ioParam.ioCompletion = nil;
    pb.ioParam.ioNamePtr = nil;
    pb.ioParam.ioVRefNum = vRefNum;
    pb.ioParam.ioBuffer = (Ptr)&info;
    pb.ioParam.ioReqCount = sizeof(info);
    err = PBHGetVolParmsSync(&pb);
    *hasDesktop = err == noErr && (info.vMAttrib & (1L << bHasDesktopMgr)) != 0;
    return err;
}


/*----------------------------------------------------------------------------
    GetLastModDateTime
    
    Get the last mod date and time of a file.
    
    Entry:  fSpec = pointer to file spec.
    
    Exit:   function result = error code.
            *lastModDateTime = last mod date and time.
----------------------------------------------------------------------------*/

static OSErr GetLastModDateTime(const FSSpec *fSpec, unsigned long *lastModDateTime)
{
    CInfoPBRec  pBlock;
    OSErr       err = noErr;
    
    pBlock.hFileInfo.ioNamePtr = (StringPtr)fSpec->name;
    pBlock.hFileInfo.ioVRefNum = fSpec->vRefNum;
    pBlock.hFileInfo.ioFDirIndex = 0;
    pBlock.hFileInfo.ioDirID = fSpec->parID;
    err = PBGetCatInfoSync(&pBlock);
    if (err != noErr) return err;
    *lastModDateTime = pBlock.hFileInfo.ioFlMdDat;
    return noErr;
}


/*----------------------------------------------------------------------------
    FindAppOnVolume 
    
    Find an application on a volume.
    
    Entry:  sig = application signature.
            vRefNum = vol ref num
            
    Exit:   function result = error code
                = afpItemNotFound if app not found on vol.
            *file = file spec for application on volume.
----------------------------------------------------------------------------*/

static OSErr FindAppOnVolume (OSType sig, short vRefNum, FSSpec *file)
{
    DTPBRec     pb;
    OSErr       err = noErr;
    short       ioDTRefNum, i;
    FInfo       fInfo;
    FSSpec      candidate;
    unsigned long lastModDateTime, maxLastModDateTime;

    memset(&pb, 0, sizeof(DTPBRec));
    pb.ioCompletion = nil;
    pb.ioVRefNum = vRefNum;
    pb.ioNamePtr = nil;
    err = PBDTGetPath(&pb);
    if (err != noErr) return err;
    ioDTRefNum = pb.ioDTRefNum;

    memset(&pb, 0, sizeof(DTPBRec));
    pb.ioCompletion = nil;
    pb.ioIndex = 0;
    pb.ioFileCreator = sig;
    pb.ioNamePtr = file->name;
    pb.ioDTRefNum = ioDTRefNum;
    err = PBDTGetAPPLSync(&pb);
    
    if (err == fnfErr || err == paramErr) return afpItemNotFound;
    if (err != noErr) return err;

    file->vRefNum = vRefNum;
    file->parID = pb.ioAPPLParID;
    
    err = FSpGetFInfo(file, &fInfo);
    if (err == noErr) return noErr;
    
    i = 1;
    maxLastModDateTime = 0;
    while (true)
    {
        memset(&pb, 0, sizeof(DTPBRec)); 
        pb.ioCompletion = nil;
        pb.ioIndex = i;
        pb.ioFileCreator = sig;
        pb.ioNamePtr = candidate.name;
        pb.ioDTRefNum = ioDTRefNum;
        err = PBDTGetAPPLSync(&pb);
        if (err != noErr) break;
        candidate.vRefNum = vRefNum;
        candidate.parID = pb.ioAPPLParID;
        err = GetLastModDateTime(file, &lastModDateTime);
        if (err == noErr) {
            if (lastModDateTime > maxLastModDateTime) {
                maxLastModDateTime = lastModDateTime;
                *file = candidate;
            }
        }
        i++;
    }
    
    return maxLastModDateTime > 0 ? noErr : afpItemNotFound;
}


/*----------------------------------------------------------------------------
    GetIndVolume 
    
    Get a volume reference number by volume index.
    
    Entry:  index = volume index
            
    Exit:   function result = error code.
            *vRefNum = vol ref num of indexed volume.
----------------------------------------------------------------------------*/

static OSErr GetIndVolume(short index, short *vRefNum)
{
    HParamBlockRec pb;
    Str63 volumeName;
    OSErr err = noErr;
    
    pb.volumeParam.ioCompletion = nil;
    pb.volumeParam.ioNamePtr = volumeName;
    pb.volumeParam.ioVolIndex = index;
    
    err = PBHGetVInfoSync(&pb);
    
    *vRefNum = pb.volumeParam.ioVRefNum;
    return err;
}


// Private NSPR functions
static unsigned long gJanuaryFirst1970Seconds = 0;
/*
 * The geographic location and time zone information of a Mac
 * are stored in extended parameter RAM.  The ReadLocation
 * produdure uses the geographic location record, MachineLocation,
 * to read the geographic location and time zone information in
 * extended parameter RAM.
 *
 * Because serial port and SLIP conflict with ReadXPram calls,
 * we cache the call here.
 *
 * Caveat: this caching will give the wrong result if a session
 * extend across the DST changeover time.
 */

static void MyReadLocation(MachineLocation *loc)
{
    static MachineLocation storedLoc;
    static Boolean didReadLocation = false;
    
    if (!didReadLocation) {
        ReadLocation(&storedLoc);
        didReadLocation = true;
    }
    *loc = storedLoc;
}

static long GMTDelta(void)
{
    MachineLocation loc;
    long gmtDelta;

    MyReadLocation(&loc);
    gmtDelta = loc.u.gmtDelta & 0x00ffffff;
    if (gmtDelta & 0x00800000) {    /* test sign extend bit */
        gmtDelta |= 0xff000000;
    }
    return gmtDelta;
}

static void MacintoshInitializeTime(void)
{
    /*
     * The NSPR epoch is midnight, Jan. 1, 1970 GMT.
     *
     * At midnight Jan. 1, 1970 GMT, the local time was
     *     midnight Jan. 1, 1970 + GMTDelta().
     *
     * Midnight Jan. 1, 1970 is 86400 * (365 * (1970 - 1904) + 17)
     *     = 2082844800 seconds since the Mac epoch.
     * (There were 17 leap years from 1904 to 1970.)
     *
     * So the NSPR epoch is 2082844800 + GMTDelta() seconds since
     * the Mac epoch.  Whew! :-)
     */
    gJanuaryFirst1970Seconds = 2082844800 + GMTDelta();
}

static nsresult ConvertMacTimeToMilliseconds( PRInt64* aLastModifiedTime, PRUint32 timestamp )
{
    if ( gJanuaryFirst1970Seconds == 0)
        MacintoshInitializeTime();
    timestamp -= gJanuaryFirst1970Seconds;
    PRTime usecPerSec, dateInMicroSeconds;
    LL_I2L(dateInMicroSeconds, timestamp);
    LL_I2L(usecPerSec, PR_MSEC_PER_SEC);
    LL_MUL(*aLastModifiedTime, usecPerSec, dateInMicroSeconds);
    return NS_OK;
}

static nsresult ConvertMillisecondsToMacTime(PRInt64 aTime, PRUint32 *aOutMacTime)
{
    NS_ENSURE_ARG( aOutMacTime );
        
    PRTime usecPerSec, dateInSeconds;
    dateInSeconds = LL_ZERO;
    
    LL_I2L(usecPerSec, PR_MSEC_PER_SEC);
    LL_DIV(dateInSeconds, aTime, usecPerSec); // dateInSeconds = aTime/1,000
    LL_L2UI(*aOutMacTime, dateInSeconds);
    *aOutMacTime += 2082844800; // date + Mac epoch

    return NS_OK;
}

static void SwapSlashColon(char * s)
{
    while (*s)
    {
        if (*s == '/')
            *s++ = ':';
        else if (*s == ':')
            *s++ = '/';
        else
            *s++;
    }
} 

static void myPLstrcpy(Str255 dst, const char* src)
{
    int srcLength = strlen(src);
    NS_ASSERTION(srcLength <= 255, "Oops, Str255 can't hold >255 chars");
    if (srcLength > 255)
        srcLength = 255;
    dst[0] = srcLength;
    memcpy(&dst[1], src, srcLength);
}

static void myPLstrncpy(Str255 dst, const char* src, int inMax)
{
    int srcLength = strlen(src);
    if (srcLength > inMax)
        srcLength = inMax;
    dst[0] = srcLength;
    memcpy(&dst[1], src, srcLength);
}

#pragma mark -

// The R**co FSSpec resolver -
//  it slices, it dices, it juliannes fries and it even creates FSSpecs out of whatever you feed it
// This function will take a path and a starting FSSpec and generate a FSSpec to represent
// the target of the two.  If the intial FSSpec is null the path alone will be resolved
static OSErr ResolvePathAndSpec(const char * filePath, FSSpec *inSpec, PRBool createDirs, FSSpec *outSpec)
{
    OSErr   err = noErr;
    size_t  inLength = strlen(filePath);
    Boolean isRelative = (filePath && inSpec);
    FSSpec  tempSpec;
    Str255  ppath;
    Boolean isDirectory;
    
    if (isRelative && inSpec)
    {
        outSpec->vRefNum = inSpec->vRefNum;
        outSpec->parID = inSpec->parID;
        
        if (inSpec->name[0] != 0)
        {
            long theDirID;
            
            err = FSpGetDirectoryID(inSpec, &theDirID, &isDirectory);
        
            if (err == noErr  &&  isDirectory)
                outSpec->parID = theDirID;
            else if (err == fnfErr && createDirs)
            {
                err = FSpDirCreate(inSpec, smCurrentScript, &theDirID);
                if (err == noErr)
                    outSpec->parID = theDirID;
                else if (err == fnfErr)
                    err = dirNFErr; 
            }
        }
    }
    else
    {
        outSpec->vRefNum = 0;
        outSpec->parID = 0;
    }
    
    if (err)
        return err;
    
    // Try making an FSSpec from the path
    if (inLength < 255)
    {
        // Use tempSpec as dest because if FSMakeFSSpec returns dirNFErr, it
        // will reset the dest spec and we'll lose what we determined above.
        
        myPLstrcpy(ppath, filePath);
        err = ::FSMakeFSSpec(outSpec->vRefNum, outSpec->parID, ppath, &tempSpec);
        if (err == noErr || err == fnfErr)
            *outSpec = tempSpec;
    }
    else if (!isRelative)
    {
        err = ::FSpLocationFromFullPath(inLength, filePath, outSpec);
    }
    else
    {   // If the path is relative and >255 characters we need to manually walk the
        // path appending each node to the initial FSSpec so to reach that code we
        // set the err to bdNamErr and fall into the code below
        err = bdNamErr;
    }
    
    // If we successfully created a spec then leave
    if (err == noErr)
        return err;
    
    // We get here when the directory hierarchy needs to be created or we're resolving
    // a relative path >255 characters long
    if (err == dirNFErr || err == bdNamErr)
    {
        const char* path = filePath;
        
        if (!isRelative)    // If path is relative, we still need vRefNum & parID.
        {
            outSpec->vRefNum = 0;
            outSpec->parID = 0;
        }

        do
        {
            // Locate the colon that terminates the node.
            // But if we've a partial path (starting with a colon), find the second one.
            const char* nextColon = strchr(path + (*path == ':'), ':');
            // Well, if there are no more colons, point to the end of the string.
            if (!nextColon)
                nextColon = path + strlen(path);

            // Make a pascal string out of this node.  Include initial
            // and final colon, if any!
            myPLstrncpy(ppath, path, nextColon - path + 1);
            
            // Use this string as a relative path using the directory created
            // on the previous round (or directory 0,0 on the first round).
            err = ::FSMakeFSSpec(outSpec->vRefNum, outSpec->parID, ppath, outSpec);

            // If this was the leaf node, then we are done.
            if (!*nextColon)
                break;

            // Since there's more to go, we have to get the directory ID, which becomes
            // the parID for the next round.
            if (err == noErr)
            {
                // The directory (or perhaps a file) exists. Find its dirID.
                long dirID;
                err = ::FSpGetDirectoryID(outSpec, &dirID, &isDirectory);
                if (!isDirectory)
                    err = dupFNErr; // oops! a file exists with that name.
                if (err != noErr)
                    break;          // bail if we've got an error
                outSpec->parID = dirID;
            }
            else if ((err == fnfErr) && createDirs)
            {
                // If we got "file not found" and we're allowed to create directories 
                // then we need to create one
                err = ::FSpDirCreate(outSpec, smCurrentScript, &outSpec->parID);
                // For some reason, this usually returns fnfErr, even though it works.
                if (err == fnfErr)
                    err = noErr;
            }
            if (err != noErr)
                break;
            path = nextColon; // next round
        } while (true);
    }
    
    return err;
}

#pragma mark -
#pragma mark [nsPathParser]

class nsPathParser
{
public:
    nsPathParser(const char* path);
    
    ~nsPathParser()
    {
        if (mAllocatedBuffer)
            nsMemory::Free(mAllocatedBuffer);
    }
    
    const char* First()
    {
        return nsCRT::strtok(mBuffer, ":", &mNewString);
    }
    const char* Next()
    {
        return nsCRT::strtok(mNewString, ":", &mNewString);
    }
    const char* Remainder()
    {
        return mNewString;
    }

private:    
    char        mAutoBuffer[512];
    char        *mAllocatedBuffer;
    char        *mBuffer, *mNewString;
};

nsPathParser::nsPathParser(const char* inPath) :
    mAllocatedBuffer(nsnull), mNewString(nsnull)
{
    PRUint32 inPathLen = strlen(inPath);
    if (inPathLen >= sizeof(mAutoBuffer)) {
        mAllocatedBuffer = (char *)nsMemory::Clone(inPath, inPathLen + 1);
        mBuffer = mAllocatedBuffer;
    }
    else {
        strcpy(mAutoBuffer, inPath);
        mBuffer = mAutoBuffer;
    }
}

#pragma mark -
#pragma mark [nsFSStringConversionMac]

class nsFSStringConversionMac {
public:
     static nsresult UCSToFS(const nsAString& aIn, nsACString& aOut);  
     static nsresult FSToUCS(const nsACString& ain, nsAString& aOut);  

     static void CleanUp();

private:
     static TextEncoding GetSystemEncoding();
     static nsresult PrepareEncoder();
     static nsresult PrepareDecoder();
     
     static UnicodeToTextInfo sEncoderInfo;
     static TextToUnicodeInfo sDecoderInfo;
};

UnicodeToTextInfo nsFSStringConversionMac::sEncoderInfo = nsnull;
TextToUnicodeInfo nsFSStringConversionMac::sDecoderInfo = nsnull;

nsresult nsFSStringConversionMac::UCSToFS(const nsAString& aIn, nsACString& aOut)
{
    nsresult rv = PrepareEncoder();
    if (NS_FAILED(rv)) return rv;
    
    OSStatus err = noErr;
    char stackBuffer[512];

    aOut.Truncate(0);
    nsReadingIterator<PRUnichar> done_reading;
    aIn.EndReading(done_reading);

    // for each chunk of |aIn|...
    PRUint32 fragmentLength = 0;
    nsReadingIterator<PRUnichar> iter;
    for (aIn.BeginReading(iter); iter != done_reading && err == noErr; iter.advance(PRInt32(fragmentLength)))
    {
        fragmentLength = PRUint32(iter.size_forward());        
        UInt32 bytesLeft = fragmentLength * sizeof(UniChar);
        nsReadingIterator<PRUnichar> sub_iter(iter);
        
        do {
            UInt32 bytesRead = 0, bytesWritten = 0;
            err = ::ConvertFromUnicodeToText(sEncoderInfo,
                                             bytesLeft,
                                             (const UniChar*)sub_iter.get(),
                                             kUnicodeUseFallbacksMask | kUnicodeLooseMappingsMask,
                                             0, nsnull, nsnull, nsnull,
                                             sizeof(stackBuffer),
                                             &bytesRead,
                                             &bytesWritten,
                                             stackBuffer);
            if (err == kTECUsedFallbacksStatus)
                err = noErr;
            else if (err == kTECOutputBufferFullStatus) {
                bytesLeft -= bytesRead;
                sub_iter.advance(bytesRead / sizeof(UniChar));
            }
            aOut.Append(stackBuffer, bytesWritten);
        }
        while (err == kTECOutputBufferFullStatus);
    }
    return (err == noErr) ? NS_OK : NS_ERROR_FAILURE;
}

nsresult nsFSStringConversionMac::FSToUCS(const nsACString& aIn, nsAString& aOut)
{
    nsresult rv = PrepareDecoder();
    if (NS_FAILED(rv)) return rv;
    
    OSStatus err = noErr;
    UniChar stackBuffer[512];

    aOut.Truncate(0);
    nsReadingIterator<char> done_reading;
    aIn.EndReading(done_reading);

    // for each chunk of |aIn|...
    PRUint32 fragmentLength = 0;
    nsReadingIterator<char> iter;
    for (aIn.BeginReading(iter); iter != done_reading && err == noErr; iter.advance(PRInt32(fragmentLength)))
    {
        fragmentLength = PRUint32(iter.size_forward());        
        UInt32 bytesLeft = fragmentLength;
        nsReadingIterator<char> sub_iter(iter);
        
        do {
            UInt32 bytesRead = 0, bytesWritten = 0;
            err = ::ConvertFromTextToUnicode(sDecoderInfo,
                                             bytesLeft,
                                             sub_iter.get(),
                                             kUnicodeUseFallbacksMask | kUnicodeLooseMappingsMask,
                                             0, nsnull, nsnull, nsnull,
                                             sizeof(stackBuffer),
                                             &bytesRead,
                                             &bytesWritten,
                                             stackBuffer);
            if (err == kTECUsedFallbacksStatus)
                err = noErr;
            else if (err == kTECOutputBufferFullStatus) {
                bytesLeft -= bytesRead;
                sub_iter.advance(bytesRead);
            }
            aOut.Append((PRUnichar *)stackBuffer, bytesWritten / sizeof(PRUnichar));
        }
        while (err == kTECOutputBufferFullStatus);
    }
    return (err == noErr) ? NS_OK : NS_ERROR_FAILURE;
}

void nsFSStringConversionMac::CleanUp()
{
    if (sDecoderInfo) {
        ::DisposeTextToUnicodeInfo(&sDecoderInfo);
        sDecoderInfo = nsnull;
    }
    if (sEncoderInfo) {
        ::DisposeUnicodeToTextInfo(&sEncoderInfo);
        sEncoderInfo = nsnull;
    }  
}

TextEncoding nsFSStringConversionMac::GetSystemEncoding()
{
    OSStatus err;
    TextEncoding theEncoding;
    
    err = ::UpgradeScriptInfoToTextEncoding(smSystemScript, kTextLanguageDontCare,
        kTextRegionDontCare, NULL, &theEncoding);
    
    if (err != noErr)
        theEncoding = kTextEncodingMacRoman;
    
    return theEncoding;
}

nsresult nsFSStringConversionMac::PrepareEncoder()
{
    nsresult rv = NS_OK;
    if (!sEncoderInfo) {
        OSStatus err;
        err = ::CreateUnicodeToTextInfoByEncoding(GetSystemEncoding(), &sEncoderInfo);
        if (err)
            rv = NS_ERROR_FAILURE;
    }
    return rv;
}

nsresult nsFSStringConversionMac::PrepareDecoder()
{
    nsresult rv = NS_OK;
    if (!sDecoderInfo) {
        OSStatus err;
        err = ::CreateTextToUnicodeInfoByEncoding(GetSystemEncoding(), &sDecoderInfo);
        if (err)
            rv = NS_ERROR_FAILURE;
    }
    return rv;
}

#pragma mark -
#pragma mark [StFollowLinksState]
class StFollowLinksState
{
  public:
    StFollowLinksState(nsILocalFile *aFile) :
        mFile(aFile)
    {
        NS_ASSERTION(mFile, "StFollowLinksState passed a NULL file.");
        if (mFile)
            mFile->GetFollowLinks(&mSavedState);
    }

    StFollowLinksState(nsILocalFile *aFile, PRBool followLinksState) :
        mFile(aFile)
    {
        NS_ASSERTION(mFile, "StFollowLinksState passed a NULL file.");
        if (mFile) {
            mFile->GetFollowLinks(&mSavedState);
            mFile->SetFollowLinks(followLinksState);
        }
    }

    ~StFollowLinksState()
    {
        if (mFile)
            mFile->SetFollowLinks(mSavedState);
    }
    
  private:
    nsCOMPtr<nsILocalFile> mFile;
    PRBool mSavedState;
};

#pragma mark -
#pragma mark [nsDirEnumerator]
class nsDirEnumerator : public nsISimpleEnumerator
{
    public:

        NS_DECL_ISUPPORTS

        nsDirEnumerator()
        {
            NS_INIT_REFCNT();
        }

        nsresult Init(nsILocalFileMac* parent) 
        {
            NS_ENSURE_ARG(parent);
            nsresult rv;
            FSSpec fileSpec;

            rv = parent->GetFSSpec(&fileSpec);
            if (NS_FAILED(rv))
                return rv;

            OSErr err;
            Boolean isDirectory;
            
            err = ::FSpGetDirectoryID(&fileSpec, &mDirID, &isDirectory);
            if (err || !isDirectory)
                return NS_ERROR_FILE_NOT_DIRECTORY;
                            
            mCatInfo.hFileInfo.ioNamePtr = mItemName;
            mCatInfo.hFileInfo.ioVRefNum = fileSpec.vRefNum;
            mItemIndex = 1;
                    
            return NS_OK;
        }

        NS_IMETHOD HasMoreElements(PRBool *result) 
        {
            nsresult rv = NS_OK;
            if (mNext == nsnull) 
            {
                mItemName[0] = 0;
                mCatInfo.dirInfo.ioFDirIndex = mItemIndex;
                mCatInfo.dirInfo.ioDrDirID = mDirID;
                
                OSErr err = ::PBGetCatInfoSync(&mCatInfo);
                if (err == fnfErr)
                {
                    // end of dir entries
                    *result = PR_FALSE;
                    return  NS_OK;
                }
                
                // Make a new nsILocalFile for the new element
                FSSpec  tempSpec;
                tempSpec.vRefNum = mCatInfo.hFileInfo.ioVRefNum;
                tempSpec.parID = mDirID;
                ::BlockMoveData(mItemName, tempSpec.name, mItemName[0] + 1);
                
                rv = NS_NewLocalFileWithFSSpec(&tempSpec, PR_TRUE, getter_AddRefs(mNext));
                if (NS_FAILED(rv)) 
                    return rv;
            }
            *result = mNext != nsnull;
            return NS_OK;
        }

        NS_IMETHOD GetNext(nsISupports **result) 
        {
            NS_ENSURE_ARG_POINTER(result);
            *result = nsnull;

            nsresult rv;
            PRBool hasMore;
            rv = HasMoreElements(&hasMore);
            if (NS_FAILED(rv)) return rv;

            *result = mNext;        // might return nsnull
            NS_IF_ADDREF(*result);

            mNext = nsnull;
            ++mItemIndex;
            return NS_OK;
        }

        virtual ~nsDirEnumerator() 
        {
        }

    protected:
        nsCOMPtr<nsILocalFileMac>   mNext;

        CInfoPBRec              mCatInfo;
        short                   mItemIndex;
        long                    mDirID;
        Str63                   mItemName;
};

NS_IMPL_ISUPPORTS1(nsDirEnumerator, nsISimpleEnumerator)

#pragma mark -

OSType nsLocalFile::sCurrentProcessSignature = 0;
PRBool nsLocalFile::sHasHFSPlusAPIs = PR_FALSE;
PRBool nsLocalFile::sRunningOSX = PR_FALSE;

#pragma mark [CTOR/DTOR]
nsLocalFile::nsLocalFile() :
    mFollowLinks(PR_TRUE),
    mFollowLinksDirty(PR_TRUE),
    mSpecDirty(PR_TRUE),
    mCatInfoDirty(PR_TRUE),
    mType('TEXT'),
    mCreator(kDefaultCreator)
{
    NS_INIT_REFCNT();

    ClearFSSpec(mSpec);
    ClearFSSpec(mTargetSpec);
    
    InitClassStatics();
    if (sCurrentProcessSignature != 0)
        mCreator = sCurrentProcessSignature;
}

nsLocalFile::nsLocalFile(const nsLocalFile& srcFile) :
    mFollowLinks(srcFile.mFollowLinks),
    mFollowLinksDirty(srcFile.mFollowLinksDirty),
    mSpecDirty(srcFile.mSpecDirty),
    mSpec(srcFile.mSpec),
    mAppendedPath(srcFile.mAppendedPath),
    mTargetSpec(srcFile.mTargetSpec),
    mCatInfoDirty(srcFile.mCatInfoDirty),
    mType(srcFile.mType),
    mCreator(srcFile.mCreator)
{
    NS_INIT_REFCNT();

    if (!mCatInfoDirty)
        mCachedCatInfo = srcFile.mCachedCatInfo;
}

nsLocalFile::nsLocalFile(const FSSpec& aSpec, const nsACString& aAppendedPath) :
    mFollowLinks(PR_TRUE),
    mFollowLinksDirty(PR_TRUE),
    mSpecDirty(PR_TRUE),
    mSpec(aSpec),
    mAppendedPath(aAppendedPath),
    mCatInfoDirty(PR_TRUE),
    mType('TEXT'),
    mCreator(kDefaultCreator)
{
    NS_INIT_REFCNT();
    
    ClearFSSpec(mTargetSpec);
    
    InitClassStatics();
    if (sCurrentProcessSignature != 0)
        mCreator = sCurrentProcessSignature;
}

nsLocalFile::~nsLocalFile()
{
}

#pragma mark -
#pragma mark [nsISupports interface implementation]
NS_IMPL_THREADSAFE_ISUPPORTS3(nsLocalFile, nsILocalFileMac, nsILocalFile, nsIFile)

NS_METHOD
nsLocalFile::nsLocalFileConstructor(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
{
    NS_ENSURE_ARG_POINTER(aInstancePtr);
    NS_ENSURE_NO_AGGREGATION(outer);

    nsLocalFile* inst = new nsLocalFile();
    if (inst == NULL)
        return NS_ERROR_OUT_OF_MEMORY;
    
    nsresult rv = inst->QueryInterface(aIID, aInstancePtr);
    if (NS_FAILED(rv))
    {
        delete inst;
        return rv;
    }
    return NS_OK;
}

// This function resets any cached information about the file.
void
nsLocalFile::MakeDirty()
{
    mSpecDirty = PR_TRUE;
    mFollowLinksDirty = PR_TRUE;
    mCatInfoDirty = PR_TRUE;
    
    ClearFSSpec(mTargetSpec);
}


/* attribute PRBool followLinks; */
NS_IMETHODIMP 
nsLocalFile::GetFollowLinks(PRBool *aFollowLinks)
{
    NS_ENSURE_ARG_POINTER(aFollowLinks);
    *aFollowLinks = mFollowLinks;
    return NS_OK;
}

NS_IMETHODIMP 
nsLocalFile::SetFollowLinks(PRBool aFollowLinks)
{
    if (aFollowLinks != mFollowLinks)
    {
        mFollowLinks = aFollowLinks;
        mFollowLinksDirty = PR_TRUE;
    }
    return NS_OK;
}

NS_IMETHODIMP
nsLocalFile::ResolveAndStat()
{
    OSErr   err = noErr;
    FSSpec  resolvedSpec;
    
    // fnfErr means target spec is valid but doesn't exist.
    // If the end result is fnfErr, we're cleanly resolved.
    
    if (mSpecDirty)
    {
        if (mAppendedPath.Length())
        {
            err = ResolvePathAndSpec(mAppendedPath.get(), &mSpec, PR_FALSE, &resolvedSpec);
            if (err == noErr)
                mAppendedPath.Truncate(0);
        }
        else
            err = ::FSMakeFSSpec(mSpec.vRefNum, mSpec.parID, mSpec.name, &resolvedSpec);
	    if (err == noErr)
	    {
	        mSpec = resolvedSpec;
	        mSpecDirty = PR_FALSE;
	    }
        mFollowLinksDirty = PR_TRUE;
    }
    if (mFollowLinksDirty)
    {
        if (mFollowLinks)
        {
            // Resolve the alias to the original file.
            resolvedSpec = mSpec;
            Boolean resolvedWasFolder, resolvedWasAlias;
            err = ::ResolveAliasFile(&resolvedSpec, TRUE, &resolvedWasFolder, &resolvedWasAlias);
            if (err == noErr || err == fnfErr) {
                err = noErr;
                mTargetSpec = resolvedSpec;
                mFollowLinksDirty = PR_FALSE;
            }
        }
        else
        {
            mTargetSpec = mSpec;
            mFollowLinksDirty = PR_FALSE;
        }
        mCatInfoDirty = PR_TRUE;
    }       
    
    return (MacErrorMapper(err));
}
    

NS_IMETHODIMP  
nsLocalFile::Clone(nsIFile **file)
{
    NS_ENSURE_ARG(file);
    *file = nsnull;
    
    // Just copy-construct ourselves
    nsCOMPtr<nsILocalFile> localFile = new nsLocalFile(*this);
    if (localFile == NULL)
      return NS_ERROR_OUT_OF_MEMORY;

    *file = localFile;
    NS_ADDREF(*file);
    
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::InitWithPath(const char *filePath)
{
    // The incoming path must be a FULL path

    NS_ENSURE_ARG(filePath);
    MakeDirty();

    // If it starts with a colon, it's invalid
    if (*filePath == ':')
        return NS_ERROR_FILE_UNRECOGNIZED_PATH;
    
    nsPathParser parser(filePath);
    OSErr err;
    Str255 pascalNode;
    FSSpec nodeSpec;
    
    const char *root = parser.First();
    if (root == nsnull)
        return NS_ERROR_FILE_UNRECOGNIZED_PATH;
        
    // The first component must be an existing volume
    myPLstrcpy(pascalNode, root);
    pascalNode[++pascalNode[0]] = ':';
    err = ::FSMakeFSSpec(0, 0, pascalNode, &nodeSpec);
    if (err)
        return NS_ERROR_FILE_UNRECOGNIZED_PATH;
    
    // Build as much of a spec as possible from the rest of the path
    // What doesn't exist will be left over in mAppendedPath
    const char *nextNode;    
    while ((nextNode = parser.Next()) != nsnull) {
        long dirID;
        Boolean isDir;
        err = ::FSpGetDirectoryID(&nodeSpec, &dirID, &isDir);
        if (err || !isDir)
            break;
        myPLstrcpy(pascalNode, nextNode);
        err = ::FSMakeFSSpec(nodeSpec.vRefNum, dirID, pascalNode, &nodeSpec);
        if (err == fnfErr)
            break;
    }
    mSpec = nodeSpec;
    mAppendedPath = parser.Remainder();
    
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval)
{
// Macintosh doesn't really have mode bits, just drop them
#pragma unused (mode)

    NS_ENSURE_ARG(_retval);
    
    nsresult rv = NS_OK;
    FSSpec  spec;
    OSErr err = noErr;
    
    rv = ResolveAndStat();
    if (rv == NS_ERROR_FILE_NOT_FOUND && (flags & PR_CREATE_FILE))
        rv = NS_OK;
        
    if (flags & PR_CREATE_FILE) {
        rv = Create(nsIFile::NORMAL_FILE_TYPE, 0);
        /* If opening with the PR_EXCL flag the existence of the file prior to opening is an error */
        if ((flags & PR_EXCL) &&  (rv == NS_ERROR_FILE_ALREADY_EXISTS))
            return rv;
    }
    
    rv = GetFSSpec(&spec);
    if (NS_FAILED(rv))
        return rv;
    
    SInt8 perm;
    if (flags & PR_RDWR)
       perm = fsRdWrPerm;
    else if (flags & PR_WRONLY)
       perm = fsWrPerm;
    else
       perm = fsRdPerm;

    short refnum;
    err = ::FSpOpenDF(&spec, perm, &refnum);

    if (err == noErr && (flags & PR_TRUNCATE))
        err = ::SetEOF(refnum, 0);
    if (err == noErr && (flags & PR_APPEND))
        err = ::SetFPos(refnum, fsFromLEOF, 0);
    if (err != noErr)
        return MacErrorMapper(err);

    if ((*_retval = PR_ImportFile(refnum)) == 0)
        return NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_FILES,(PR_GetError() & 0xFFFF));
    
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::OpenANSIFileDesc(const char *mode, FILE * *_retval)
{
    NS_ENSURE_ARG(mode);
    NS_ENSURE_ARG_POINTER(_retval);
    
    nsresult rv; 
    FSSpec spec;

    rv = ResolveAndStat();
    if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND)
        return rv;
    
    if (mode[0] == 'w' || mode[0] == 'a') // Create if it doesn't exist   
    {
        if (rv == NS_ERROR_FILE_NOT_FOUND) {
            mType = (mode[1] == 'b') ? 'BiNA' : 'TEXT';
            rv = Create(nsIFile::NORMAL_FILE_TYPE, 0);
            if (NS_FAILED(rv))
                return rv;
        }
    }

    rv = GetFSSpec(&spec);
    if (NS_FAILED(rv))
        return rv;
                
#ifdef MACOSX
    // FSp_fopen() doesn't exist under macosx :-(
    nsXPIDLCString ourPath;
    rv = GetPath(getter_Copies(ourPath));
    if (NS_FAILED(rv))
        return rv;
    *_retval = fopen(ourPath, mode);
#else
    *_retval = FSp_fopen(&spec, mode);
#endif

    if (*_retval)
        return NS_OK;

    return NS_ERROR_FAILURE;
}


NS_IMETHODIMP  
nsLocalFile::Create(PRUint32 type, PRUint32 attributes)
{ 
    OSErr   err;

    if (type != NORMAL_FILE_TYPE && type != DIRECTORY_TYPE)
        return NS_ERROR_FILE_UNKNOWN_TYPE;

    FSSpec newSpec;

    if (mAppendedPath.Length())
    {   // We've got an FSSpec and an appended path so pass 'em both to ResolvePathAndSpec
        err = ResolvePathAndSpec(mAppendedPath.get(), &mSpec, PR_TRUE, &newSpec);
    }
    else
    {
        err = ::FSMakeFSSpec(mSpec.vRefNum, mSpec.parID, mSpec.name, &newSpec);
    }
    
    if (err != noErr && err != fnfErr)
        return (MacErrorMapper(err));

    switch (type)
    {
        case NORMAL_FILE_TYPE:
            SetOSTypeAndCreatorFromExtension();
            err = ::FSpCreate(&newSpec, mCreator, mType, smCurrentScript);
            break;

        case DIRECTORY_TYPE:
            {
                long newDirID;
                err = ::FSpDirCreate(&newSpec, smCurrentScript, &newDirID);
                // For some reason, this usually returns fnfErr, even though it works.
                if (err == fnfErr)
                    err = noErr;
            }
            break;
        
        default:
            return NS_ERROR_FILE_UNKNOWN_TYPE;
            break;
    }

    if (err == noErr)
    {
        mSpec = mTargetSpec = newSpec;
        mAppendedPath.Truncate(0);
    }
    
    return (MacErrorMapper(err));
}

NS_IMETHODIMP  
nsLocalFile::Append(const char *node)
{
    NS_ENSURE_ARG(node);
    if (strchr(node, ':'))
        return NS_ERROR_FILE_UNRECOGNIZED_PATH;
    
    MakeDirty();
    if (!mAppendedPath.Length())
    {
        OSErr   err;
        Boolean resolvedWasFolder, resolvedWasAlias;
        err = ::ResolveAliasFile(&mSpec, TRUE, &resolvedWasFolder, &resolvedWasAlias);
        if (err == noErr)
        {
            long    dirID;
            Boolean isDir;

            if (!resolvedWasFolder)
                return NS_ERROR_FILE_NOT_DIRECTORY;
            if ((err = ::FSpGetDirectoryID(&mSpec, &dirID, &isDir)) != noErr)
                return MacErrorMapper(err);
                
            Str255 pascalNode;
            myPLstrcpy(pascalNode, node);
            err = ::FSMakeFSSpec(mSpec.vRefNum, dirID, pascalNode, &mSpec);
            if (err && err != fnfErr)
                return MacErrorMapper(err);
        }
        else if (err == fnfErr)
            mAppendedPath.Assign(node);
        else
            return MacErrorMapper(err);
    }
    else
    {
        if (mAppendedPath.First() != ':')
            mAppendedPath.Insert(':', 0);
        mAppendedPath.Append(":");
        mAppendedPath.Append(node);
    }
    
    return NS_OK;
}
    
NS_IMETHODIMP  
nsLocalFile::AppendRelativePath(const char *relPath)
{
    NS_ENSURE_ARG(relPath);
    
    nsresult        rv;
    nsPathParser    parser(relPath);
    const char*     node = parser.First();
    
    while (node)
    {
        if (NS_FAILED(rv = Append(node)))
            return rv;
        node = parser.Next();
    }
        
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::GetLeafName(char * *aLeafName)
{
    NS_ENSURE_ARG_POINTER(aLeafName);
 
    // See if we've had a path appended
    if (mAppendedPath.Length())
    {
        const char* temp = mAppendedPath.get();
        if (temp == nsnull)
            return NS_ERROR_FILE_UNRECOGNIZED_PATH;

        const char* leaf = strrchr(temp, ':');
        
        // if the working path is just a node without any directory delimeters.
        if (leaf == nsnull)
            leaf = temp;
        else
            leaf++;

        *aLeafName = (char*) nsMemory::Clone(leaf, strlen(leaf)+1);
    }
    else
    {
        // We don't have an appended path so grab the leaf name from the FSSpec
        // Convert the Pascal string to a C string              
        PRInt32 len = mSpec.name[0];
        char* leafName = (char *)nsMemory::Alloc(len + 1);
        if (!leafName) return NS_ERROR_OUT_OF_MEMORY;               
        ::BlockMoveData(&mSpec.name[1], leafName, len);
        leafName[len] = '\0';
        *aLeafName = leafName;
    }
 
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::SetLeafName(const char * aLeafName)
{
    NS_ENSURE_ARG(aLeafName);

    MakeDirty();

    if (mAppendedPath.Length())
    {   // Lop off the end of the appended path and replace it with the new leaf name
        PRInt32 offset = mAppendedPath.RFindChar(':');
        if (offset || ((!offset) && (1 < mAppendedPath.Length())))
        {
            mAppendedPath.Truncate(offset + 1);
        }
        mAppendedPath.Append(aLeafName);
    }
    else
    {
        // We don't have an appended path so directly modify the FSSpec
        myPLstrcpy(mSpec.name, aLeafName);
    }
    
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::GetPath(char **_retval)
{
    NS_ENSURE_ARG_POINTER(_retval);

    nsCAutoString fsCharSetPathStr;
                
#if TARGET_CARBON
    if (sHasHFSPlusAPIs) // should always be true under Carbon, but in case...
    {
        OSErr err;
        nsresult rv;
        nsAutoString ucPathString;
        
        FSRef nodeRef;
        FSCatalogInfo catalogInfo;
        catalogInfo.parentDirID = 0;
        err = ::FSpMakeFSRef(&mSpec, &nodeRef);
        
        if (err == fnfErr) {
            FSSpec parentDirSpec;               
            err = GetParentFolderSpec(mSpec, parentDirSpec);
            if (err == noErr) {
                const char *startPtr = (const char*)&mSpec.name[1];
                nsFSStringConversionMac::FSToUCS(Substring(startPtr, startPtr + PRUint32(mSpec.name[0])), ucPathString);
                err = ::FSpMakeFSRef(&parentDirSpec, &nodeRef);
            }
        }

        while (err == noErr && catalogInfo.parentDirID != fsRtParID) {
            HFSUniStr255 nodeName;
            FSRef parentRef;
            err = ::FSGetCatalogInfo(&nodeRef,
                                     kFSCatInfoNodeFlags + kFSCatInfoParentDirID,
                                     &catalogInfo,
                                     &nodeName,
                                     nsnull,
                                     &parentRef);
            if (err == noErr)
            {
                if (catalogInfo.nodeFlags & kFSNodeIsDirectoryMask)
                    nodeName.unicode[nodeName.length++] = PRUnichar(':');
                const PRUnichar* nodeNameUni = (const PRUnichar*) nodeName.unicode;
                ucPathString.Insert(Substring(nodeNameUni, nodeNameUni + nodeName.length), 0);
                nodeRef = parentRef;
            }
        }
        
        rv = MacErrorMapper(err);
        if (NS_FAILED(rv))
            return rv;
        rv = nsFSStringConversionMac::UCSToFS(ucPathString, fsCharSetPathStr);
        if (NS_FAILED(rv))
            return rv;
    }
    else
#endif
    {
        // Now would be a good time to call the code that makes an FSSpec into a path
        short   fullPathLen;
        Handle  fullPathHandle;
        (void)::FSpGetFullPath(&mSpec, &fullPathLen, &fullPathHandle);
        if (!fullPathHandle)
            return NS_ERROR_OUT_OF_MEMORY;
        
        ::HLock(fullPathHandle);        
        fsCharSetPathStr.Assign(*fullPathHandle, fullPathLen);
        ::DisposeHandle(fullPathHandle);
    }

    // We need to make sure that even if we have a path to a
    // directory we don't return the trailing colon. It breaks
    // the component manager. (Bugzilla bug #26102) 
    if (fsCharSetPathStr.Last() == ':')
        fsCharSetPathStr.Truncate(fsCharSetPathStr.Length() - 1);
    
    // Now, tack on mAppendedPath. It never ends in a colon.
    if (mAppendedPath.Length())
    {
        if (mAppendedPath.First() != ':')
            fsCharSetPathStr.Append(":");
        fsCharSetPathStr.Append(mAppendedPath);
    }
    
    *_retval = ToNewCString(fsCharSetPathStr);
    if (!*_retval)
        return NS_ERROR_OUT_OF_MEMORY;
    
#ifdef XP_MACOSX
    // Watch out for a really big hack, coming soon to this space!
    char* slashified = (char*) nsMemory::Alloc(sizeof("/Volumes/") + strlen(*_retval));
    if (slashified) {
        strcpy(slashified, "/Volumes/");
        strcat(slashified, *_retval);
        nsMemory::Free(*_retval);
        *_retval = slashified;
        char *colon = strchr(slashified, ':');
        while (colon != NULL) {
            *colon = '/';
            colon = strchr(colon + 1, ':');
        }
    }
#endif

    return NS_OK;
}

nsresult nsLocalFile::MoveCopy( nsIFile* newParentDir, const char* newName, PRBool isCopy, PRBool followLinks )
{
    OSErr macErr;
    FSSpec srcSpec;
    Str255 newPascalName;
    nsresult rv;
    
    StFollowLinksState srcFollowState(this, followLinks);
    rv = GetFSSpec(&srcSpec);
    if ( NS_FAILED( rv ) )
        return rv;  
    
    // If newParentDir == nsnull, it's a simple rename
    if ( !newParentDir )
    {
        NS_ENSURE_ARG( newName );
        myPLstrncpy( newPascalName, newName, 255 );
        macErr = ::FSpRename( &srcSpec, newPascalName );
        return MacErrorMapper( macErr );
    }

    nsCOMPtr<nsILocalFileMac> destDir(do_QueryInterface( newParentDir ));
    StFollowLinksState destFollowState(destDir, followLinks);
    FSSpec destSpec;
    rv = destDir->GetFSSpec(&destSpec);
    if ( NS_FAILED( rv ) )
        return rv;
    
    long dirID;
    Boolean isDirectory;    
    macErr = ::FSpGetDirectoryID(&destSpec, &dirID, &isDirectory);      
    if ( macErr || !isDirectory )
        return NS_ERROR_FILE_DESTINATION_NOT_DIR;

    if ( newName )
        myPLstrncpy( newPascalName, newName, 255);
    else
        memcpy(newPascalName, srcSpec.name, srcSpec.name[0] + 1);
    if ( isCopy )
    {
        macErr = ::FSpGetDirectoryID(&srcSpec, &dirID, &isDirectory);       
        if (macErr == noErr)
        {
            if ( isDirectory )
                macErr = MacFSpDirectoryCopyRename( &srcSpec, &destSpec, newPascalName, NULL, 0, true, NULL );
            else
                macErr = ::FSpFileCopy( &srcSpec, &destSpec, newPascalName, NULL, 0, true );
        }
    }
    else
    {
        macErr= ::FSpMoveRenameCompat(&srcSpec, &destSpec, newPascalName);
        if ( macErr == diffVolErr)
        {
                // On a different Volume so go for Copy and then delete
                rv = CopyTo( newParentDir, newName );
                if ( NS_FAILED ( rv ) )
                    return rv;
                return Remove( PR_TRUE );
        }
    }   
    return MacErrorMapper( macErr );
}

NS_IMETHODIMP  
nsLocalFile::CopyTo(nsIFile *newParentDir, const char *newName)
{
    return MoveCopy( newParentDir, newName, PR_TRUE, PR_FALSE );
}

NS_IMETHODIMP  
nsLocalFile::CopyToFollowingLinks(nsIFile *newParentDir, const char *newName)
{
    return MoveCopy( newParentDir, newName, PR_TRUE, PR_TRUE );
}

NS_IMETHODIMP  
nsLocalFile::MoveTo(nsIFile *newParentDir, const char *newName)
{
    return MoveCopy( newParentDir, newName, PR_FALSE, PR_FALSE );
}

NS_IMETHODIMP  
nsLocalFile::Load(PRLibrary * *_retval)
{
    PRBool isFile;
    nsresult rv = IsFile(&isFile);

    if (NS_FAILED(rv))
        return rv;
    
    if (! isFile)
        return NS_ERROR_FILE_IS_DIRECTORY;

  NS_TIMELINE_START_TIMER("PR_LoadLibrary");

#if !TARGET_CARBON      
    // This call to SystemTask is here to give the OS time to grow its
    // FCB (file control block) list, which it seems to be unable to
    // do unless we yield some time to the OS. See bugs 64978 & 70543
    // for the whole story.
    ::SystemTask();
#endif

    // Use the new PR_LoadLibraryWithFlags which allows us to use a FSSpec
    PRLibSpec libSpec;
    libSpec.type = PR_LibSpec_MacIndexedFragment;
    libSpec.value.mac_indexed_fragment.fsspec = &mTargetSpec;
    libSpec.value.mac_indexed_fragment.index = 0;
    *_retval =  PR_LoadLibraryWithFlags(libSpec, 0);
    
  NS_TIMELINE_STOP_TIMER("PR_LoadLibrary");
  NS_TIMELINE_MARK_TIMER("PR_LoadLibrary");

    if (*_retval)
        return NS_OK;

    return NS_ERROR_NULL_POINTER;
}

NS_IMETHODIMP  
nsLocalFile::Remove(PRBool recursive)
{
    OSErr err;
    nsresult rv;
    FSSpec specToDelete;
    PRBool isDir;
    
    StFollowLinksState(this, PR_FALSE);
    
    rv = IsDirectory(&isDir); // Calls ResolveAndStat()
    if (NS_FAILED(rv))
        return rv;  
    rv = GetFSSpec(&specToDelete);
    if (NS_FAILED(rv))
        return rv;
    
    if (isDir && recursive)
        err = ::DeleteDirectory( specToDelete.vRefNum, specToDelete.parID, specToDelete.name );
    else
        err = ::HDelete( specToDelete.vRefNum, specToDelete.parID, specToDelete.name );
    
    return MacErrorMapper( err );
}

NS_IMETHODIMP  
nsLocalFile::GetLastModifiedTime(PRInt64 *aLastModifiedTime)
{
    NS_ENSURE_ARG(aLastModifiedTime);
    *aLastModifiedTime = 0;
    
    nsresult rv = ResolveAndStat();
    if ( NS_FAILED( rv ) )
        return rv;      
    rv = UpdateCachedCatInfo(PR_TRUE);
    if ( NS_FAILED( rv ) )
        return rv;
    
    // The mod date is in the same spot for files and dirs.
    return ConvertMacTimeToMilliseconds( aLastModifiedTime, mCachedCatInfo.hFileInfo.ioFlMdDat );
}

NS_IMETHODIMP  
nsLocalFile::SetLastModifiedTime(PRInt64 aLastModifiedTime)
{
    nsresult rv = ResolveAndStat();
    if ( NS_FAILED(rv) )
        return rv;
    
    PRUint32 macTime = 0;
    OSErr err = noErr;
    
    ConvertMillisecondsToMacTime(aLastModifiedTime, &macTime);
    
    if (NS_SUCCEEDED(rv = UpdateCachedCatInfo(PR_TRUE)))
    {
        if (mCachedCatInfo.hFileInfo.ioFlAttrib & ioDirMask)
        {
            mCachedCatInfo.dirInfo.ioDrMdDat = macTime; 
            mCachedCatInfo.dirInfo.ioDrParID = mFollowLinks ? mTargetSpec.parID : mSpec.parID;
        }
        else
        {
            mCachedCatInfo.hFileInfo.ioFlMdDat = macTime;
            mCachedCatInfo.hFileInfo.ioDirID = mFollowLinks ? mTargetSpec.parID : mSpec.parID;
        }   
            
        err = ::PBSetCatInfoSync(&mCachedCatInfo);
        if (err != noErr)
            return MacErrorMapper(err);
    }
    
    return rv;
}

NS_IMETHODIMP  
nsLocalFile::GetLastModifiedTimeOfLink(PRInt64 *aLastModifiedTime)
{
    NS_ENSURE_ARG(aLastModifiedTime);
    
    nsresult rv;
    PRBool isLink;
    
    rv = IsSymlink(&isLink);
    if (NS_FAILED(rv))
        return rv;
    if (!isLink)
        return NS_ERROR_FAILURE;
    
    StFollowLinksState followState(this, PR_FALSE);
    return GetLastModifiedTime(aLastModifiedTime);
}

NS_IMETHODIMP  
nsLocalFile::SetLastModifiedTimeOfLink(PRInt64 aLastModifiedTime)
{
    nsresult rv;
    PRBool isLink;
    
    rv = IsSymlink(&isLink);
    if (NS_FAILED(rv))
        return rv;
    if (!isLink)
        return NS_ERROR_FAILURE;
    
    StFollowLinksState followState(this, PR_FALSE);
    return SetLastModifiedTime(aLastModifiedTime);
}


NS_IMETHODIMP  
nsLocalFile::GetFileSize(PRInt64 *aFileSize)
{
    NS_ENSURE_ARG(aFileSize);
    nsresult rv;
    
    *aFileSize = LL_Zero();
    
    if (NS_SUCCEEDED(rv = ResolveAndStat()) && NS_SUCCEEDED(rv = UpdateCachedCatInfo(PR_TRUE)))
    {
        if (!(mCachedCatInfo.hFileInfo.ioFlAttrib & ioDirMask))
        {
            long dataSize = mCachedCatInfo.hFileInfo.ioFlLgLen;
            long resSize = mCachedCatInfo.hFileInfo.ioFlRLgLen;
            
            // For now we've only got 32 bits of file size info
            PRInt64 dataInt64 = LL_Zero();
            PRInt64 resInt64 = LL_Zero();
            
            // WARNING!!!!!!
            // 
            // For now we do NOT add the data and resource fork sizes as there are several
            // assumptions in the code (notably in form submit) that only the data fork is
            // used. 
            // LL_I2L(resInt64, resSize);
            
            LL_I2L(dataInt64, dataSize);
            
            LL_ADD((*aFileSize), dataInt64, resInt64);
        }
        // leave size at zero for dirs
    }
            
    return rv;
}


NS_IMETHODIMP  
nsLocalFile::SetFileSize(PRInt64 aFileSize)
{
    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv))
        return rv;
        
    short   refNum;
    OSErr   err;
    PRInt32 aNewLength;
    
    LL_L2I(aNewLength, aFileSize);
    
    // Need to open the file to set the size
    if (::FSpOpenDF(&mTargetSpec, fsWrPerm, &refNum) != noErr)
        return NS_ERROR_FILE_ACCESS_DENIED;

    err = ::SetEOF(refNum, aNewLength);
        
    // Close the file unless we got an error that it was already closed
    if (err != fnOpnErr)
        (void)::FSClose(refNum);
        
    if (err != noErr)
        return MacErrorMapper(err);
        
    return MacErrorMapper(err);
}

NS_IMETHODIMP  
nsLocalFile::GetFileSizeOfLink(PRInt64 *aFileSize)
{
    NS_ENSURE_ARG(aFileSize);

    StFollowLinksState followState(this, PR_FALSE);
    return GetFileSize(aFileSize);
}

NS_IMETHODIMP  
nsLocalFile::GetDiskSpaceAvailable(PRInt64 *aDiskSpaceAvailable)
{
    NS_ENSURE_ARG(aDiskSpaceAvailable);
        
    PRInt64 space64Bits;

    LL_I2L(space64Bits , LONG_MAX);
    
    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv))
        return rv;

    XVolumeParam    pb;
    pb.ioCompletion = nsnull;
    pb.ioVolIndex = 0;
    pb.ioNamePtr = nsnull;
    pb.ioVRefNum = mFollowLinks ? mTargetSpec.vRefNum : mSpec.vRefNum;
    
    // we should check if this call is available
    OSErr err = ::PBXGetVolInfoSync(&pb);
    
    if (err == noErr)
    {
        const UnsignedWide& freeBytes = UInt64ToUnsignedWide(pb.ioVFreeBytes);
#ifdef HAVE_LONG_LONG
    space64Bits = UnsignedWideToUInt64(freeBytes);
#else
        space64Bits.lo = freeBytes.lo;
        space64Bits.hi = freeBytes.hi;
#endif
    }
        
    *aDiskSpaceAvailable = space64Bits;

    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::GetParent(nsIFile * *aParent)
{
    NS_ENSURE_ARG_POINTER(aParent);
    *aParent = nsnull;
    
    nsresult rv = NS_OK;
    PRInt32 offset;

    nsCOMPtr<nsILocalFileMac> localFile;
    PRInt32     appendedLen = mAppendedPath.Length();
    OSErr       err;
                
    if (!appendedLen || (appendedLen == 1 && mAppendedPath.CharAt(0) == ':'))
    {
        rv = ResolveAndStat();
        //if the file does not exist, does not mean that the parent does not.
        if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND)
            return rv;

        CInfoPBRec  pBlock = {0};
        FSSpec      parentFolderSpec;
        parentFolderSpec.name[0] = 0;

        pBlock.dirInfo.ioVRefNum = mSpec.vRefNum;
        pBlock.dirInfo.ioDrDirID = mSpec.parID;
        pBlock.dirInfo.ioNamePtr = (StringPtr)parentFolderSpec.name;
        pBlock.dirInfo.ioFDirIndex = -1;        //get info on parID
        err = PBGetCatInfoSync(&pBlock);
        if (err != noErr) 
            return MacErrorMapper(err);
        parentFolderSpec.vRefNum = mSpec.vRefNum;
        parentFolderSpec.parID = pBlock.dirInfo.ioDrParID;
        
        localFile = new nsLocalFile;
        if (!localFile)
            return NS_ERROR_OUT_OF_MEMORY;
        rv = localFile->InitWithFSSpec(&parentFolderSpec);
        if (NS_FAILED(rv))
            return rv;
    }
    else
    {
        // trim off the last component of the appended path
        // construct a new file from our spec + trimmed path

        nsCAutoString parentAppendage(mAppendedPath);
        
        if (parentAppendage.Last() == ':')
            parentAppendage.Truncate(appendedLen - 1);
        if ((offset = parentAppendage.RFindChar(':')) != -1)
            parentAppendage.Truncate(offset);
        else
            parentAppendage.Truncate(0);
            
        localFile = new nsLocalFile(mSpec, parentAppendage);
        if (!localFile)
            return NS_ERROR_OUT_OF_MEMORY;
    }
    *aParent = localFile;
    NS_ADDREF(*aParent);

    return rv;
}


NS_IMETHODIMP  
nsLocalFile::Exists(PRBool *_retval)
{
    NS_ENSURE_ARG(_retval);
    *_retval = PR_FALSE;
    
    nsresult rv = ResolveAndStat();
    if (NS_SUCCEEDED(rv)) {
        if (NS_SUCCEEDED(UpdateCachedCatInfo(PR_TRUE)))
            *_retval = PR_TRUE;
    }
        
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::IsWritable(PRBool *outIsWritable)
{
    NS_ENSURE_ARG(outIsWritable);
    *outIsWritable = PR_TRUE;

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;
    
    rv = UpdateCachedCatInfo(PR_TRUE);
    if (NS_FAILED(rv)) return rv;
    
    *outIsWritable = !(mCachedCatInfo.hFileInfo.ioFlAttrib & kioFlAttribLockedMask);
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::IsReadable(PRBool *_retval)
{
    NS_ENSURE_ARG(_retval);

    // is it ever not readable on Mac?
    *_retval = PR_TRUE;
    return NS_OK;
}


NS_IMETHODIMP  
nsLocalFile::IsExecutable(PRBool *outIsExecutable)
{
    NS_ENSURE_ARG(outIsExecutable);
    *outIsExecutable = PR_FALSE;    // Assume failure

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;

#if TARGET_CARBON
    // If we're running under OS X ask LaunchServices if we're executable
    if (sRunningOSX)
    {
        if ( (UInt32)LSCopyItemInfoForRef != (UInt32)kUnresolvedCFragSymbolAddress )
        {
            FSRef   theRef;
            LSRequestedInfo theInfoRequest = kLSRequestAllInfo;
            LSItemInfoRecord theInfo;
            
            if (::FSpMakeFSRef(&mTargetSpec, &theRef) == noErr)
            {
                if (::LSCopyItemInfoForRef(&theRef, theInfoRequest, &theInfo) == noErr)
                {
                    if ((theInfo.flags & kLSItemInfoIsApplication) != 0)
                        *outIsExecutable = PR_TRUE;
                }
            }
        }
    }
    else
#endif
    {
    OSType fileType;
    rv = GetFileType(&fileType);
    if (NS_FAILED(rv)) return rv;
    
    *outIsExecutable = (fileType == 'APPL' || fileType == 'appe' || fileType == 'FNDR');
    }
    
    return NS_OK;
}


NS_IMETHODIMP  
nsLocalFile::IsDirectory(PRBool *outIsDir)
{
    NS_ENSURE_ARG(outIsDir);
    *outIsDir = PR_FALSE;

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;
    
    rv = UpdateCachedCatInfo(PR_FALSE);
    if (NS_FAILED(rv)) return rv;
    
    *outIsDir = (mCachedCatInfo.hFileInfo.ioFlAttrib & ioDirMask) != 0;
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::IsFile(PRBool *outIsFile)
{
    NS_ENSURE_ARG(outIsFile);
    *outIsFile = PR_FALSE;

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;
    
    rv = UpdateCachedCatInfo(PR_FALSE);
    if (NS_FAILED(rv)) return rv;

    *outIsFile = (mCachedCatInfo.hFileInfo.ioFlAttrib & ioDirMask) == 0;
    return NS_OK;
}

NS_IMETHODIMP  
nsLocalFile::IsHidden(PRBool *_retval)
{
    NS_ENSURE_ARG(_retval);
    *_retval = PR_FALSE;

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;

    rv = UpdateCachedCatInfo(PR_FALSE);
    if (NS_FAILED(rv)) return rv;
    
    *_retval = (mCachedCatInfo.hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible) != 0;     
    return NS_OK;
}

NS_IMETHODIMP
nsLocalFile::IsSymlink(PRBool *_retval)
{
    NS_ENSURE_ARG(_retval);
    *_retval = PR_FALSE;

    nsresult rv = ResolveAndStat();
    if (NS_FAILED(rv)) return rv;

    Boolean isAlias, isFolder;
    if (::IsAliasFile(&mSpec, &isAlias, &isFolder) == noErr)
        *_retval = isAlias;
    return NS_OK;
}

NS_IMETHODIMP
nsLocalFile::Equals(nsIFile *inFile, PRBool *_retval)
{
    NS_ENSURE_ARG(inFile);
    NS_ENSURE_ARG(_retval);
    *_retval = PR_FALSE;

    // Building paths is expensive. If we can get the FSSpecs of
    // both (they or their parents exist) just compare the specs.
    nsCOMPtr<nsILocalFileMac> inMacFile(do_QueryInterface(inFile));
    FSSpec fileSpec, inFileSpec;
    if (NS_SUCCEEDED(GetFSSpec(&fileSpec)) && inMacFile && NS_SUCCEEDED(inMacFile->GetFSSpec(&inFileSpec)))
        *_retval = IsEqualFSSpec(fileSpec, inFileSpec);
    else
    {
        nsXPIDLCString filePath;
        GetPath(getter_Copies(filePath));
    
        nsXPIDLCString inFilePath;
        inFile->GetPath(getter_Copies(inFilePath));
        
        if (nsCRT::strcasecmp(inFilePath, filePath) == 0)
            *_retval = PR_TRUE;
    }
    return NS_OK;
}

NS_IMETHODIMP
nsLocalFile::Contains(nsIFile *inFile, PRBool recur, PRBool *outContains)
{
  /* Note here that we make no attempt to deal with the problem
     of folder aliases. Doing a 'Contains' test and dealing with
     folder aliases is Hard. Think about it.
  */
    *outContains = PR_FALSE;

    PRBool isDir;
    nsresult rv = IsDirectory(&isDir);    // need to cache this
    if (NS_FAILED(rv)) return rv;
    if (!isDir) return NS_OK;   // must be a dir to contain someone

    nsCOMPtr<nsILocalFileMac> macFile(do_QueryInterface(inFile));
    if (!macFile) return NS_OK;     // trying to compare non-local with local file

    FSSpec  mySpec = mSpec;
    FSSpec  compareSpec;

    // NOTE: we're not resolving inFile if it was an alias
    StFollowLinksState followState(macFile, PR_FALSE);
    rv = macFile->GetFSSpec(&compareSpec);
    if (NS_FAILED(rv)) return rv;

    // if they are on different volumes, bail
    if (mSpec.vRefNum != compareSpec.vRefNum)
        return NS_OK;

    // if recur == true, test every parent, otherwise just test the first one
    // (yes, recur does not get set in this loop)
    OSErr   err = noErr;
    do
    {
        FSSpec  parentFolderSpec;
        err = GetParentFolderSpec(compareSpec, parentFolderSpec);
        if (err != noErr) break;                // we reached the top   

        if (IsEqualFSSpec(parentFolderSpec, mySpec))
        {
            *outContains = PR_TRUE;
            break;
        }
        
        compareSpec = parentFolderSpec;
    } while (recur);
      
    return NS_OK;
}



NS_IMETHODIMP
nsLocalFile::GetTarget(char **_retval)
{   
    NS_ENSURE_ARG(_retval);
    *_retval = nsnull;
    
    PRBool symLink;
    
    nsresult rv = IsSymlink(&symLink);
    if (NS_FAILED(rv))
        return rv;

    if (!symLink)
        return NS_ERROR_FILE_INVALID_PATH;
        
    StFollowLinksState followState(this, PR_TRUE);
    return GetPath(_retval);
}


NS_IMETHODIMP
nsLocalFile::GetDirectoryEntries(nsISimpleEnumerator * *entries)
{
    nsresult rv;
    
    *entries = nsnull;

    PRBool isDir;
    rv = IsDirectory(&isDir);
    if (NS_FAILED(rv)) 
        return rv;
    if (!isDir)
        return NS_ERROR_FILE_NOT_DIRECTORY;

    nsDirEnumerator* dirEnum = new nsDirEnumerator();
    if (dirEnum == nsnull)
        return NS_ERROR_OUT_OF_MEMORY;
    NS_ADDREF(dirEnum);
    rv = dirEnum->Init(this);
    if (NS_FAILED(rv)) 
    {
        NS_RELEASE(dirEnum);
        return rv;
    }
    
    *entries = dirEnum;
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::GetURL(char * *aURL)
{
     NS_ENSURE_ARG_POINTER(aURL);
     *aURL = nsnull;
     
     nsresult rv;
     char* ePath = nsnull;
     nsCAutoString escPath;
 
     rv = GetPath(&ePath);
     if (NS_SUCCEEDED(rv)) {
 
         SwapSlashColon(ePath);
         
         // Escape the path with the directory mask
         rv = nsStdEscape(ePath, esc_Directory+esc_Forced, escPath);
         if (NS_SUCCEEDED(rv)) {
           if (escPath[escPath.Length() - 1] != '/') {
             PRBool dir;
             rv = IsDirectory(&dir);
             NS_ASSERTION(NS_SUCCEEDED(rv), "Cannot tell if this is a directory");
             if (NS_SUCCEEDED(rv) && dir) {
               // make sure we have a trailing slash
               escPath += "/";
             }             
           }
           escPath.Insert("file:///", 0);
           
           *aURL = ToNewCString(escPath);
           rv = *aURL ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
         }
     }
     CRTFREEIF(ePath);
     return rv;
}

NS_IMETHODIMP nsLocalFile::SetURL(const char * aURL)
{
     NS_ENSURE_ARG(aURL);
     nsresult rv;
     
     nsXPIDLCString host, directory, fileBaseName, fileExtension;
     
     rv = ParseURL(aURL, getter_Copies(host), getter_Copies(directory),
                   getter_Copies(fileBaseName), getter_Copies(fileExtension));
     if (NS_FAILED(rv)) return rv;
                   
     nsCAutoString path;
     nsCAutoString component;
 
     if (host)
     {
         // We can end up with a host when given: file:// instead of file:///
         // Check to see if the host is a volume name - If so prepend it
         Str255 volName;
         FSSpec volSpec;
         
         myPLstrcpy(volName, host);
         volName[++volName[0]] = ':';
         if (::FSMakeFSSpec(0, 0, volName, &volSpec) == noErr)
             path += host;
     }
     if (directory)
     {
         nsStdEscape(directory, esc_Directory, component);
         path += component;
         SwapSlashColon((char*)path.get());
     }
     if (fileBaseName)
     {
         nsStdEscape(fileBaseName, esc_FileBaseName, component);
         path += component;
     }
     if (fileExtension)
     {
         nsStdEscape(fileExtension, esc_FileExtension, component);
         path += '.';
         path += component;
     }
     
     nsUnescape((char*)path.get());
 
     // wack off leading :'s
     if (path.CharAt(0) == ':')
         path.Cut(0, 1);
 
     rv = InitWithPath(path.get());
          
     return rv;

}

NS_IMETHODIMP
nsLocalFile::GetPersistentDescriptor(char * *aPersistentDescriptor)
{
   NS_ENSURE_ARG_POINTER(aPersistentDescriptor);
   *aPersistentDescriptor = nsnull;
   
   nsresult  rv = ResolveAndStat();
   if ( NS_FAILED( rv ) )
     return rv;

   AliasHandle    aliasH;
   OSErr err = ::NewAlias(nil, &mTargetSpec, &aliasH);
   if (err != noErr)
     return MacErrorMapper(err);

   PRUint32 bytes = ::GetHandleSize((Handle) aliasH);
   HLock((Handle) aliasH);
   char* buf = PL_Base64Encode((const char*)*aliasH, bytes, nsnull); // Passing nsnull for dest makes NULL-term string
   ::DisposeHandle((Handle) aliasH);
   NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);

   *aPersistentDescriptor = buf;

   return NS_OK;
}

NS_IMETHODIMP
nsLocalFile::SetPersistentDescriptor(const char * aPersistentDescriptor)
{
   NS_ENSURE_ARG(aPersistentDescriptor);
   
   nsresult rv = NS_OK;

   PRUint32 dataSize = nsCRT::strlen(aPersistentDescriptor);
   char* decodedData = PL_Base64Decode((const char*)aPersistentDescriptor, dataSize, nsnull);
   // Cast to an alias record and resolve.
   AliasHandle aliasH = nsnull;
   if (::PtrToHand(decodedData, &(Handle)aliasH, (dataSize * 3) / 4) != noErr)
      rv = NS_ERROR_OUT_OF_MEMORY;
   PR_Free(decodedData);
   NS_ENSURE_SUCCESS(rv, rv);

   Boolean changed;
   FSSpec resolvedSpec;
   OSErr err;
   err = ::ResolveAlias(nsnull, aliasH, &resolvedSpec, &changed);
   if (err == fnfErr) // resolvedSpec is valid in this case
      err = noErr;
   rv = MacErrorMapper(err);
   DisposeHandle((Handle) aliasH);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return InitWithFSSpec(&resolvedSpec);   
}

#pragma mark -

// a stack-based, exception safe class for an AEDesc

#pragma mark
class StAEDesc: public AEDesc
{
public:
                    StAEDesc()
                    {
                        descriptorType = typeNull;
                        dataHandle = nil;
                    }
                                        
                    ~StAEDesc()
                    {
                        ::AEDisposeDesc(this);
                    }

                    void Clear()
                    {
                        ::AEDisposeDesc(this);
                        descriptorType = typeNull;
                        dataHandle = nil;
                    }
                                        
private:
    // disallow copies and assigns
                            StAEDesc(const StAEDesc& rhs);      // copy constructor
    StAEDesc&   operator= (const StAEDesc&rhs);     // throws OSErrs

};

#pragma mark -
#pragma mark [Utility methods]


nsresult nsLocalFile::UpdateCachedCatInfo(PRBool forceUpdate) 
{
    if (!mCatInfoDirty && !forceUpdate)
        return NS_OK;
        
    FSSpec spectoUse = mFollowLinks ? mTargetSpec : mSpec;
    mCachedCatInfo.hFileInfo.ioCompletion = nsnull;
    mCachedCatInfo.hFileInfo.ioFDirIndex = 0; // use dirID and name
    mCachedCatInfo.hFileInfo.ioVRefNum = spectoUse.vRefNum;
    mCachedCatInfo.hFileInfo.ioDirID = spectoUse.parID;
    mCachedCatInfo.hFileInfo.ioNamePtr = spectoUse.name;

    OSErr err = ::PBGetCatInfoSync(&mCachedCatInfo);
    if (err == noErr)
    {
        mCatInfoDirty = PR_FALSE;
        return NS_OK;
    }
    return MacErrorMapper(err);
}


nsresult nsLocalFile::FindRunningAppBySignature (OSType aAppSig, FSSpec& outSpec, ProcessSerialNumber& outPsn)
{
    ProcessInfoRec  info;
    FSSpec                  tempFSSpec;
    OSErr                   err = noErr;
    
    outPsn.highLongOfPSN = 0;
    outPsn.lowLongOfPSN  = kNoProcess;

    while (PR_TRUE)
    {
        err = ::GetNextProcess(&outPsn);
        if (err == procNotFound) break;
        if (err != noErr) return NS_ERROR_FAILURE;
        info.processInfoLength = sizeof(ProcessInfoRec);
        info.processName = nil;
        info.processAppSpec = &tempFSSpec;
        err = ::GetProcessInformation(&outPsn, &info);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        if (info.processSignature == aAppSig)
        {
            outSpec = tempFSSpec;
            return NS_OK;
        }
    }
    
    return NS_ERROR_FILE_NOT_FOUND;     // really process not found
}


nsresult nsLocalFile::FindRunningAppByFSSpec(const FSSpec& appSpec, ProcessSerialNumber& outPsn)
{
    ProcessInfoRec  info;
    FSSpec                  tempFSSpec;
    OSErr                   err = noErr;
    
    outPsn.highLongOfPSN = 0;
    outPsn.lowLongOfPSN  = kNoProcess;

    while (PR_TRUE)
    {
        err = ::GetNextProcess(&outPsn);
        if (err == procNotFound) break;     
        if (err != noErr) return NS_ERROR_FAILURE;
        info.processInfoLength = sizeof(ProcessInfoRec);
        info.processName = nil;
        info.processAppSpec = &tempFSSpec;
        err = ::GetProcessInformation(&outPsn, &info);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        if (IsEqualFSSpec(appSpec, *info.processAppSpec))
        {
            return NS_OK;
        }
    }
    
    return NS_ERROR_FILE_NOT_FOUND;     // really process not found
}


nsresult nsLocalFile::FindAppOnLocalVolumes(OSType sig, FSSpec &outSpec)
{
    OSErr   err;
    
    // get the system volume
    long        systemFolderDirID;
    short       sysVRefNum;
    err = FindFolder(kOnSystemDisk, kSystemFolderType, false, &sysVRefNum, &systemFolderDirID);
    if (err != noErr) return NS_ERROR_FAILURE;

    short   vRefNum = sysVRefNum;
    short   index = 0;
    
    while (true)
    {
        if (index == 0 || vRefNum != sysVRefNum)
        {
            // should we avoid AppleShare volumes?
            
            Boolean hasDesktopDB;
            err = VolHasDesktopDB(vRefNum, &hasDesktopDB);
            if (err != noErr) return err;
            if (hasDesktopDB)
            {
                err = FindAppOnVolume(sig, vRefNum, &outSpec);
                if (err != afpItemNotFound) return err;
            }
        }
        index++;
        err = GetIndVolume(index, &vRefNum);
        if (err == nsvErr) return fnfErr;
        if (err != noErr) return err;
    }

    return NS_OK;
}

#define aeSelectionKeyword  'fsel'
#define kAEOpenSelection    'sope'
#define kAERevealSelection  'srev'
#define kFinderType         'FNDR'

NS_IMETHODIMP nsLocalFile::Launch()
{
  AppleEvent        aeEvent = {0, nil};
  AppleEvent        aeReply = {0, nil};
  StAEDesc          aeDirDesc, listElem, myAddressDesc, fileList;
  FSSpec                dirSpec, appSpec;
  AliasHandle           DirAlias, FileAlias;
  OSErr             errorResult = noErr;
  ProcessSerialNumber   process;
  
  // for launching a file, we'll use mTargetSpec (which is both a resolved spec and a resolved alias)
  ResolveAndStat();
    
#if TARGET_CARBON
    if (sRunningOSX)
    { // We're running under Mac OS X, LaunchServices here we come

        // First we make sure the LaunchServices routine we want is implemented
        if ( (UInt32)LSOpenFSRef != (UInt32)kUnresolvedCFragSymbolAddress )
        {
            FSRef   theRef;
            if (::FSpMakeFSRef(&mTargetSpec, &theRef) == noErr)
            {
                (void)::LSOpenFSRef(&theRef, NULL);
            }
        }
    }
    else
#endif
    { // We're running under Mac OS 8.x/9.x, use the Finder Luke
  nsresult rv = FindRunningAppBySignature ('MACS', appSpec, process);
  if (NS_SUCCEEDED(rv))
  { 
    errorResult = AECreateDesc(typeProcessSerialNumber, (Ptr)&process, sizeof(process), &myAddressDesc);
    if (errorResult == noErr)
    {
      /* Create the FinderEvent */
      errorResult = AECreateAppleEvent(kFinderType, kAEOpenSelection, &myAddressDesc, kAutoGenerateReturnID, kAnyTransactionID,
                                       &aeEvent);   
      if (errorResult == noErr) 
      {
        errorResult = FSMakeFSSpec(mTargetSpec.vRefNum, mTargetSpec.parID, nil, &dirSpec);
        NewAlias(nil, &dirSpec, &DirAlias);
        /* Create alias for file */
        NewAlias(nil, &mTargetSpec, &FileAlias);
        
        /* Create the file  list */
         errorResult = AECreateList(nil, 0, false, &fileList);
        /*  create the folder  descriptor */
        HLock((Handle)DirAlias);
        errorResult = AECreateDesc(typeAlias, (Ptr)*DirAlias, GetHandleSize((Handle)DirAlias), &aeDirDesc);
        HUnlock((Handle)DirAlias);
        if (errorResult == noErr)
        {
          errorResult = AEPutParamDesc(&aeEvent, keyDirectObject, &aeDirDesc);
          if ( errorResult == noErr) 
          {
            /*  create the file descriptor and add to aliasList */
            HLock((Handle)FileAlias);
            errorResult = AECreateDesc(typeAlias, (Ptr)*FileAlias, GetHandleSize((Handle)FileAlias), &listElem);
            HLock((Handle)FileAlias);
            if (errorResult == noErr)
            {
              errorResult = AEPutDesc(&fileList, 0, &listElem);
              if (errorResult == noErr)
              {
                /* Add the file alias list to the event */
                errorResult = AEPutParamDesc(&aeEvent, aeSelectionKeyword, &fileList);
                if (errorResult == noErr)
                    AESend(&aeEvent, &aeReply, kAEWaitReply + kAENeverInteract 
                                  + kAECanSwitchLayer, kAEHighPriority, kAEDefaultTimeout, nil, nil);
              }
            }
          }
        }
      }
    }
  }
    }
                      
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::Reveal()
{
  FSSpec            specToReveal;
  AppleEvent        aeEvent = {0, nil};
  AppleEvent        aeReply = {0, nil};
  StAEDesc          aeDirDesc, listElem, myAddressDesc, fileList;
  OSErr             errorResult = noErr;
  ProcessSerialNumber   process;
  FSSpec appSpec;
    
  nsresult rv = ResolveAndStat();
  if (NS_FAILED(rv))
    return rv;
  rv = GetFSSpec(&specToReveal); // Pay attention to followLinks
  if (NS_FAILED(rv))
    return rv;
  
  rv = FindRunningAppBySignature ('MACS', appSpec, process);
  if (NS_SUCCEEDED(rv))
  { 
    errorResult = AECreateDesc(typeProcessSerialNumber, (Ptr)&process, sizeof(process), &myAddressDesc);
    if (errorResult == noErr)
    {
      /* Create the FinderEvent */
#if TARGET_CARBON
    // The Finder under OS X uses a different event to reveal
    if (sRunningOSX)
      errorResult = AECreateAppleEvent(kAEMiscStandards, kAEMakeObjectsVisible, &myAddressDesc, kAutoGenerateReturnID, kAnyTransactionID,
                                       &aeEvent);   
    else
#endif
      errorResult = AECreateAppleEvent(kFinderType, kAERevealSelection, &myAddressDesc, kAutoGenerateReturnID, kAnyTransactionID,
                                       &aeEvent);   
      if (errorResult == noErr) 
      {
        /* Create the file  list */
        errorResult = AECreateList(nil, 0, false, &fileList);
        if (errorResult == noErr) 
        {
          errorResult = AEPutPtr(&fileList, 0, typeFSS, &specToReveal, sizeof(FSSpec));
          
          if (errorResult == noErr)
          {
#if TARGET_CARBON
            // When we're sending the event under OS X the FSSpec must be a keyDirectObject
            if (sRunningOSX)
              errorResult = AEPutParamDesc(&aeEvent, keyDirectObject, &fileList);
            else
#endif
            errorResult = AEPutParamDesc(&aeEvent,keySelection, &fileList);

            if (errorResult == noErr)
            {
              errorResult = AESend(&aeEvent, &aeReply, kAENoReply, kAENormalPriority, kAEDefaultTimeout, nil, nil);
              if (errorResult == noErr)
                SetFrontProcess(&process);
            }
          }
        }
      }
    }
  }
    
  return NS_OK;
}

nsresult nsLocalFile::MyLaunchAppWithDoc(const FSSpec& appSpec, const FSSpec* aDocToLoad, PRBool aLaunchInBackground)
{
    ProcessSerialNumber thePSN = {0};
    StAEDesc            target;
    StAEDesc            docDesc;
    StAEDesc            launchDesc;
    StAEDesc            docList;
    AppleEvent      theEvent = {0, nil};
    AppleEvent      theReply = {0, nil};
    OSErr               err = noErr;
    Boolean             autoParamValue = false;
    Boolean             running = false;
    nsresult            rv = NS_OK;
    
#if TARGET_CARBON
    if (sRunningOSX)
    { // Under Mac OS X we'll use LaunchServices
        
        // First we make sure the LaunchServices routine we want is implemented
        if ( (UInt32)LSOpenFromRefSpec != (UInt32)kUnresolvedCFragSymbolAddress )
        {
            FSRef   appRef;
            FSRef   docRef;
            LSLaunchFlags       theLaunchFlags = kLSLaunchDefaults;
            LSLaunchFSRefSpec   thelaunchSpec;
            
            if (::FSpMakeFSRef(&appSpec, &appRef) != noErr)
                return NS_ERROR_FAILURE;
            
            if (aDocToLoad)
                if (::FSpMakeFSRef(aDocToLoad, &docRef) != noErr)
                    return NS_ERROR_FAILURE;
            
            if (aLaunchInBackground)
                theLaunchFlags |= kLSLaunchDontSwitch;
                
            memset(&thelaunchSpec, 0, sizeof(LSLaunchFSRefSpec));
            
            thelaunchSpec.appRef = &appRef;
            if (aDocToLoad)
            {
                thelaunchSpec.numDocs = 1;
                thelaunchSpec.itemRefs = &docRef;
            }
            thelaunchSpec.launchFlags = theLaunchFlags;
            
            err = ::LSOpenFromRefSpec(&thelaunchSpec, NULL);
            NS_ASSERTION((err != noErr), "Error calling LSOpenFromRefSpec");
            if (err != noErr) return NS_ERROR_FAILURE;
        }
    }
    else
#endif
    { // The old fashioned way for Mac OS 8.x/9.x
    rv = FindRunningAppByFSSpec(appSpec, thePSN);
    running = NS_SUCCEEDED(rv);
    
    err = AECreateDesc(typeProcessSerialNumber, &thePSN, sizeof(thePSN), &target); 
    if (err != noErr) return NS_ERROR_FAILURE;
    
    err = AECreateAppleEvent(kCoreEventClass, aDocToLoad ? kAEOpenDocuments : kAEOpenApplication, &target,
                            kAutoGenerateReturnID, kAnyTransactionID, &theEvent);
    if (err != noErr) return NS_ERROR_FAILURE;
    
    if (aDocToLoad)
    {
        err = AECreateList(nil, 0, false, &docList);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        err = AECreateDesc(typeFSS, aDocToLoad, sizeof(FSSpec), &docDesc);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        err = AEPutDesc(&docList, 0, &docDesc);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        err = AEPutParamDesc(&theEvent, keyDirectObject, &docList);
        if (err != noErr) return NS_ERROR_FAILURE;
    }
    
    if (running)
    {
        err = AESend(&theEvent, &theReply, kAENoReply, kAENormalPriority, kNoTimeOut, nil, nil);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        if (!aLaunchInBackground)
        {
            err = ::SetFrontProcess(&thePSN);
            if (err != noErr) return NS_ERROR_FAILURE;
        }
    }
    else
    {
        LaunchParamBlockRec launchThis = {0};
        PRUint16                        launchControlFlags = (launchContinue | launchNoFileFlags);
        if (aLaunchInBackground)
            launchControlFlags |= launchDontSwitch;
        
        err = AECoerceDesc(&theEvent, typeAppParameters, &launchDesc);
        if (err != noErr) return NS_ERROR_FAILURE;

        launchThis.launchAppSpec = (FSSpecPtr)&appSpec;
#if TARGET_CARBON && ACCESSOR_CALLS_ARE_FUNCTIONS
        ::AEGetDescData(&launchDesc, &launchThis.launchAppParameters, sizeof(launchThis.launchAppParameters));
#else
        // no need to lock this handle.
            launchThis.launchAppParameters = (AppParametersPtr) *(launchDesc.dataHandle);
#endif
        launchThis.launchBlockID = extendedBlock;
        launchThis.launchEPBLength = extendedBlockLen;
        launchThis.launchFileFlags = 0;
        launchThis.launchControlFlags = launchControlFlags;
        err = ::LaunchApplication(&launchThis);
        if (err != noErr) return NS_ERROR_FAILURE;
        
        // let's be nice and wait until it's running
        const PRUint32  kMaxTimeToWait = 60;        // wait 1 sec max
        PRUint32                endTicks = ::TickCount() + kMaxTimeToWait;

        PRBool                  foundApp = PR_FALSE;
        
        do
        {
            EventRecord     theEvent;
            (void)WaitNextEvent(nullEvent, &theEvent, 1, NULL);

            ProcessSerialNumber     psn;
            foundApp = NS_SUCCEEDED(FindRunningAppByFSSpec(appSpec, psn));
        
        } while (!foundApp && (::TickCount() <= endTicks));

        NS_ASSERTION(foundApp, "Failed to find app after launching it");
    }
    
    if (theEvent.dataHandle != nil) AEDisposeDesc(&theEvent);
    if (theReply.dataHandle != nil) AEDisposeDesc(&theReply);
    }

    return NS_OK;
}


#pragma mark -
#pragma mark [Methods that will not be implemented on Mac]

NS_IMETHODIMP
nsLocalFile::Normalize()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP  
nsLocalFile::GetPermissions(PRUint32 *aPermissions)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP  
nsLocalFile::GetPermissionsOfLink(PRUint32 *aPermissionsOfLink)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}


NS_IMETHODIMP  
nsLocalFile::SetPermissions(PRUint32 aPermissions)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP  
nsLocalFile::SetPermissionsOfLink(PRUint32 aPermissions)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP  
nsLocalFile::IsSpecial(PRBool *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

#pragma mark -
#pragma mark [nsILocalFileMac]
// Implementation of Mac specific finctions from nsILocalFileMac


NS_IMETHODIMP nsLocalFile::InitWithFSSpec(const FSSpec *fileSpec)
{
    MakeDirty();
    mSpec          = *fileSpec;
    mTargetSpec    = *fileSpec;
    mAppendedPath  = "";
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::InitToAppWithCreatorCode(OSType aAppCreator)
{
    FSSpec              appSpec;
    ProcessSerialNumber psn;
    
#if TARGET_CARBON
    if (sRunningOSX)
    { // If we're running under OS X use LaunchServices to determine the app
      // corresponding to the creator code
        if ( (UInt32)LSFindApplicationForInfo != (UInt32)kUnresolvedCFragSymbolAddress )
        {
            FSRef    theRef;
            if (::LSFindApplicationForInfo(aAppCreator, NULL, NULL, &theRef, NULL) == noErr)
            {
                FSCatalogInfoBitmap   whichInfo = kFSCatInfoNone;
                
                if (::FSGetCatalogInfo(&theRef, whichInfo, NULL, NULL, &appSpec, NULL) == noErr)
                    return InitWithFSSpec(&appSpec);
            }
            
            // If we get here we didn't find an app
            return NS_ERROR_FILE_NOT_FOUND;
        }
    }
#endif

    // is the app running?
    nsresult rv = FindRunningAppBySignature(aAppCreator, appSpec, psn);
    if (rv == NS_ERROR_FILE_NOT_FOUND)
    {
        // we have to look on disk
        rv = FindAppOnLocalVolumes(aAppCreator, appSpec);
        if (NS_FAILED(rv)) return rv;
    }
    else if (NS_FAILED(rv))
        return rv;

    // init with the spec here
    return InitWithFSSpec(&appSpec);
}

NS_IMETHODIMP nsLocalFile::GetFSSpec(FSSpec *fileSpec)
{
    NS_ENSURE_ARG(fileSpec);
    nsresult rv = ResolveAndStat();
    if (rv == NS_ERROR_FILE_NOT_FOUND)
        rv = NS_OK;
    if (NS_SUCCEEDED(rv))
        *fileSpec = mFollowLinks ? mTargetSpec : mSpec;
    
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::GetFileType(OSType *aFileType)
{
    NS_ENSURE_ARG(aFileType);

    FSSpec fileSpec;
    (void)GetFSSpec(&fileSpec); 
    
    FInfo info;
    OSErr err = ::FSpGetFInfo(&fileSpec, &info);
    if (err != noErr)
    {
        *aFileType = mType;
        return NS_ERROR_FILE_NOT_FOUND;
    }
    
    *aFileType = info.fdType;
    
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::SetFileType(OSType aFileType)
{
    mType = aFileType;

    FSSpec fileSpec;
    (void)GetFSSpec(&fileSpec); 
    
    FInfo info;
    OSErr err = ::FSpGetFInfo(&fileSpec, &info);
    if (err != noErr)
        return NS_ERROR_FILE_NOT_FOUND;
            
    info.fdType = aFileType;    
    err = ::FSpSetFInfo(&fileSpec, &info);
    if (err != noErr)
        return NS_ERROR_FILE_ACCESS_DENIED;
    
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::GetFileCreator(OSType *aCreator)
{
    NS_ENSURE_ARG(aCreator);
    
    FSSpec fileSpec;
    (void)GetFSSpec(&fileSpec); 
    
    FInfo info;
    OSErr err = ::FSpGetFInfo(&fileSpec, &info);
    if (err != noErr)
    {
        *aCreator = mCreator;
        return NS_ERROR_FILE_NOT_FOUND;
    }
    
    *aCreator = info.fdCreator; 
    
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::SetFileCreator(OSType aCreator)
{
    if (aCreator == CURRENT_PROCESS_CREATOR)
        aCreator = sCurrentProcessSignature;
        
    mCreator = aCreator;

    FSSpec fileSpec;
    (void)GetFSSpec(&fileSpec); 
    
    FInfo info;
    OSErr err = ::FSpGetFInfo(&fileSpec, &info);
    if (err != noErr)
        return NS_ERROR_FILE_NOT_FOUND;
            
    info.fdCreator = aCreator;  
    err = ::FSpSetFInfo(&fileSpec, &info);
    if (err != noErr)
        return NS_ERROR_FILE_ACCESS_DENIED;
    
    return NS_OK;
}

NS_IMETHODIMP nsLocalFile::SetFileTypeAndCreatorFromExtension(const char *aExtension)
{
    NS_ENSURE_ARG(aExtension);
    return SetOSTypeAndCreatorFromExtension(aExtension);
}

NS_IMETHODIMP nsLocalFile::SetFileTypeAndCreatorFromMIMEType(const char *aMIMEType)
{
    NS_ENSURE_ARG(aMIMEType);

    nsresult rv;
    nsCOMPtr<nsIInternetConfigService> icService(do_GetService
        (NS_INTERNETCONFIGSERVICE_CONTRACTID, &rv));
        
    if (NS_SUCCEEDED(rv))
    {
        nsCOMPtr<nsIMIMEInfo> mimeInfo;
        PRUint32 fileType = 'TEXT';
        PRUint32 fileCreator = nsILocalFileMac::CURRENT_PROCESS_CREATOR;
    
        rv = icService->FillInMIMEInfo(aMIMEType, 
                nsnull, getter_AddRefs(mimeInfo));
        if (NS_SUCCEEDED(rv))
            rv = mimeInfo->GetMacType(&fileType);
        if (NS_SUCCEEDED(rv))
            rv = mimeInfo->GetMacCreator(&fileCreator);
        if (NS_SUCCEEDED(rv))
            rv = SetFileType(fileType);
        if (NS_SUCCEEDED(rv))
            rv  = SetFileCreator(fileCreator);    
    }
    
    return rv;
}

NS_IMETHODIMP  
nsLocalFile::GetFileSizeWithResFork(PRInt64 *aFileSize)
{
    NS_ENSURE_ARG(aFileSize);
    
    *aFileSize = LL_Zero();

    ResolveAndStat();
    
    long dataSize = 0;
    long resSize = 0;
    
    OSErr err = FSpGetFileSize(&mTargetSpec, &dataSize, &resSize);
                               
    if (err != noErr)
        return MacErrorMapper(err);
    
    // For now we've only got 32 bits of file size info
    PRInt64 dataInt64 = LL_Zero();
    PRInt64 resInt64 = LL_Zero();
    
    // Combine the size of the resource and data forks
    LL_I2L(resInt64, resSize);
    LL_I2L(dataInt64, dataSize);
    LL_ADD((*aFileSize), dataInt64, resInt64);
    
    return NS_OK;
}


// this nsLocalFile points to the app. We want to launch it, optionally with the document.
NS_IMETHODIMP
nsLocalFile::LaunchWithDoc(nsILocalFile* aDocToLoad, PRBool aLaunchInBackground)
{
    // are we launchable?
    PRBool isExecutable;
    nsresult rv = IsExecutable(&isExecutable);
    if (NS_FAILED(rv)) return rv;
    if (!isExecutable) return NS_ERROR_FILE_EXECUTION_FAILED;
    
    FSSpec          docSpec;
    FSSpecPtr       docSpecPtr = nsnull;
    
    nsCOMPtr<nsILocalFileMac> macDoc = do_QueryInterface(aDocToLoad);
    if (macDoc)
    {
        rv = macDoc->GetFSSpec(&docSpec); // XXX GetTargetFSSpec
        if (NS_FAILED(rv)) return rv;
        
        docSpecPtr = &docSpec;
    }
    
    FSSpec  appSpec;
    rv = GetFSSpec(&appSpec); // XXX GetResolvedFSSpec
    if (NS_FAILED(rv)) return rv;
    
    rv = MyLaunchAppWithDoc(appSpec, docSpecPtr, aLaunchInBackground);
    return rv;
}


NS_IMETHODIMP
nsLocalFile::OpenDocWithApp(nsILocalFile* aAppToOpenWith, PRBool aLaunchInBackground)
{
    // if aAppToOpenWith is nil, we have to find the app from the creator code
    // of the document
    nsresult rv = NS_OK;
    
    FSSpec      appSpec;
    
    if (aAppToOpenWith)
    {
        nsCOMPtr<nsILocalFileMac> appFileMac = do_QueryInterface(aAppToOpenWith, &rv);
        if (!appFileMac) return rv;
    
        rv = appFileMac->GetFSSpec(&appSpec); // XXX GetTargetFSSpec
        if (NS_FAILED(rv)) return rv;

        // is it launchable?
        PRBool isExecutable;
        rv = aAppToOpenWith->IsExecutable(&isExecutable);
        if (NS_FAILED(rv)) return rv;
        if (!isExecutable) return NS_ERROR_FILE_EXECUTION_FAILED;
    }
    else
    {
        // look for one
        OSType  fileCreator;
        rv = GetFileCreator(&fileCreator);
        if (NS_FAILED(rv)) return rv;
        
        // just make one on the stack
        nsLocalFile localAppFile;
        rv = localAppFile.InitToAppWithCreatorCode(fileCreator);
        if (NS_FAILED(rv)) return rv;
        
        rv = localAppFile.GetFSSpec(&appSpec); // GetTargetFSSpec
        if (NS_FAILED(rv)) return rv;
    }
    
    FSSpec      docSpec;
    rv = GetFSSpec(&docSpec); // XXX GetResolvedFSSpec
    if (NS_FAILED(rv)) return rv;

    rv = MyLaunchAppWithDoc(appSpec, &docSpec, aLaunchInBackground);
    return rv;
}

nsresult nsLocalFile::SetOSTypeAndCreatorFromExtension(const char* extension)
{
    nsresult rv;
    
    nsXPIDLCString localExtBuf;
    const char *extPtr;
    
    if (!extension)
    {
        rv = GetLeafName(getter_Copies(localExtBuf));
        extPtr = strrchr(localExtBuf, '.');
        if (!extPtr)
            return NS_ERROR_FAILURE;
        ++extPtr;   
    }
    else
    {
        extPtr = extension;
        if (*extPtr == '.')
            ++extPtr;
    }
    
    nsCOMPtr<nsIInternetConfigService> icService = 
             do_GetService(NS_INTERNETCONFIGSERVICE_CONTRACTID, &rv);
    if (NS_SUCCEEDED(rv))
    {
        nsCOMPtr<nsIMIMEInfo> mimeInfo;
        rv = icService->GetMIMEInfoFromExtension(extPtr, getter_AddRefs(mimeInfo));
        if (NS_SUCCEEDED(rv))
        {
            PRUint32 osType;
            rv = mimeInfo->GetMacType(&osType);
            if (NS_SUCCEEDED(rv))
                mType = osType;
            PRBool skip;
            rv = ExtensionIsOnExceptionList(extPtr, &skip);
            if (NS_SUCCEEDED(rv) && !skip)
            {
                rv = mimeInfo->GetMacCreator(&osType);
                if (NS_SUCCEEDED(rv))
                    mCreator = osType;
            }
        }
    }
    return rv;
}

nsresult nsLocalFile::ExtensionIsOnExceptionList(const char *extension, PRBool *onList)
{
    // Probably want to make a global list somewhere in the future
    // for now, just check for "html" and "htm"
    
    *onList = PR_FALSE;
    
    if (!nsCRT::strcasecmp(extension, "html") ||
        !nsCRT::strcasecmp(extension, "htm"))
        *onList = PR_TRUE;
    return NS_OK;
}


void nsLocalFile::InitClassStatics()
{
    OSErr err;
    

    if (sCurrentProcessSignature == 0)
    {
        ProcessSerialNumber psn;
        ProcessInfoRec  info;
        
        psn.highLongOfPSN = 0;
        psn.lowLongOfPSN  = kCurrentProcess;

        info.processInfoLength = sizeof(ProcessInfoRec);
        info.processName = nil;
        info.processAppSpec = nil;
        err = ::GetProcessInformation(&psn, &info);
        if (err == noErr)
            sCurrentProcessSignature = info.processSignature;
        // Try again next time if error
    }
    
    static PRBool didHFSPlusCheck = PR_FALSE;
    if (!didHFSPlusCheck)
    {
        long response;
        err = ::Gestalt(gestaltFSAttr, &response);
        sHasHFSPlusAPIs = (err == noErr && (response & (1 << gestaltHasHFSPlusAPIs)) != 0);
        didHFSPlusCheck = PR_TRUE;
    }
    
    static PRBool didOSXCheck = PR_FALSE;
    if (!didOSXCheck)
    {
        long version;
        sRunningOSX = (::Gestalt(gestaltSystemVersion, &version) == noErr && version >= 0x00001000);
        didOSXCheck = PR_TRUE;
    }
}


#pragma mark -

// Handy dandy utility create routine for something or the other
nsresult 
NS_NewLocalFile(const char* path, PRBool followLinks, nsILocalFile* *result)
{
    nsLocalFile* file = new nsLocalFile();
    if (file == nsnull)
        return NS_ERROR_OUT_OF_MEMORY;
    NS_ADDREF(file);

    file->SetFollowLinks(followLinks);

    if (path) {
        nsresult rv = file->InitWithPath(path);
        if (NS_FAILED(rv)) {
            NS_RELEASE(file);
            return rv;
        }
    }
    *result = file;
    return NS_OK;
}

nsresult 
NS_NewLocalFileWithFSSpec(FSSpec* inSpec, PRBool followLinks, nsILocalFileMac* *result)
{
    nsLocalFile* file = new nsLocalFile();
    if (file == nsnull)
        return NS_ERROR_OUT_OF_MEMORY;
    NS_ADDREF(file);

    file->SetFollowLinks(followLinks);

    nsresult rv = file->InitWithFSSpec(inSpec);
    if (NS_FAILED(rv)) {
        NS_RELEASE(file);
        return rv;
    }
    *result = file;
    return NS_OK;
}