mac.c

压缩算法的源代码

        if (vRefNum != 0) {
            wdpb.ioCompletion = false;
            wdpb.ioNamePtr = st;
            wdpb.ioWDIndex = 0;
            wdpb.ioVRefNum = vRefNum;
            err = PBHGetVol(&wdpb, false);

            if (err == noErr) {
                wAppVRefNum = wdpb.ioWDVRefNum;
                lAppDirID = wdpb.ioWDDirID;
            }
        }

        /* is the disk we're using formatted for HFS? */
        HFSFlag = IsHFSDisk(wAppVRefNum);
    }

    return;
} /* mactest */





/***********************/
/* Function macmkdir() */
/***********************/

int macmkdir(char *path, short nVRefNum, long lDirID)
{
    OSErr    err = -1;

    if (path != 0 && strlen(path)<256 && HFSFlag == true) {
        HParamBlockRec    hpbr;
        Str255    st;

        c2pstr(path);
        if ((nVRefNum == 0) && (lDirID == 0))
        {
            hpbr.fileParam.ioNamePtr = st;
            hpbr.fileParam.ioCompletion = NULL;
            err = PBHGetVol((WDPBPtr)&hpbr, false);
            nVRefNum = hpbr.wdParam.ioWDVRefNum;
            lDirID = hpbr.wdParam.ioWDDirID;
        }
        else
        {
            err = noErr;
        }
        if (err == noErr) {
            hpbr.fileParam.ioCompletion = NULL;
            hpbr.fileParam.ioVRefNum = nVRefNum;
            hpbr.fileParam.ioDirID = lDirID;
            hpbr.fileParam.ioNamePtr = (StringPtr)path;
            err = PBDirCreate(&hpbr, false);
        }
        p2cstr(path);
    }

    return (int)err;
} /* macmkdir */





/****************************/
/* Function ResolveMacVol() */
/****************************/

void ResolveMacVol(short nVRefNum, short *pnVRefNum, long *plDirID, StringPtr pst)
{
    if (HFSFlag)
    {
        WDPBRec  wdpbr;
        Str255   st;
        OSErr    err;

        wdpbr.ioCompletion = (ProcPtr)NULL;
        wdpbr.ioNamePtr = st;
        wdpbr.ioVRefNum = nVRefNum;
        wdpbr.ioWDIndex = 0;
        wdpbr.ioWDProcID = 0;
        wdpbr.ioWDVRefNum = 0;
        err = PBGetWDInfo( &wdpbr, false );
        if ( err == noErr )
        {
            if (pnVRefNum)
                *pnVRefNum = wdpbr.ioWDVRefNum;
            if (plDirID)
                *plDirID = wdpbr.ioWDDirID;
            if (pst)
                BlockMove( st, pst, st[0]+1 );
        }
    }
    else
    {
        if (pnVRefNum)
            *pnVRefNum = nVRefNum;
        if (plDirID)
            *plDirID = 0;
        if (pst)
            *pst = 0;
    }
}





/**********************/
/* Function macopen() */
/**********************/

short macopen(char *sz, short nFlags, short nVRefNum, long lDirID)
{
    OSErr   err;
    Str255  st;
    char    chPerms = (!nFlags) ? fsRdPerm : fsRdWrPerm;
    short   nFRefNum;

    c2pstr( sz );
    BlockMove( sz, st, sz[0]+1 );
    p2cstr( sz );
    if (HFSFlag)
    {
        if (nFlags > 1)
            err = HOpenRF( nVRefNum, lDirID, st, chPerms, &nFRefNum);
        else
            err = HOpen( nVRefNum, lDirID, st, chPerms, &nFRefNum);
    }
    else
    {
        /*
         * Have to use PBxxx style calls since the high level
         * versions don't support specifying permissions
         */
        ParamBlockRec    pbr;

        pbr.ioParam.ioNamePtr = st;
        pbr.ioParam.ioVRefNum = gnVRefNum;
        pbr.ioParam.ioVersNum = 0;
        pbr.ioParam.ioPermssn = chPerms;
        pbr.ioParam.ioMisc = 0;
        if (nFlags >1)
            err = PBOpenRF( &pbr, false );
        else
            err = PBOpen( &pbr, false );
        nFRefNum = pbr.ioParam.ioRefNum;
    }
    if ( err || (nFRefNum == 1) )
        return -1;
    else {
        if ( nFlags )
            SetEOF( nFRefNum, 0 );
        return nFRefNum;
    }
}





/***********************/
/* Function macfopen() */
/***********************/

FILE *macfopen(char *filename, char *mode, short nVRefNum, long lDirID)
    {
        short outfd, fDataFork=TRUE;
        MACINFO mi;
        OSErr err;

        fMacZipped = FALSE;
        c2pstr(filename);
        if (extra_field &&
            (lrec.extra_field_length > sizeof(MACINFOMIN)) &&
            (lrec.extra_field_length <= sizeof(MACINFO))) {
            BlockMove(extra_field, &mi, lrec.extra_field_length);
            if ((makeword((uch *)&mi.header) == 1992) &&
                (makeword((uch *)&mi.data) ==
                    lrec.extra_field_length-sizeof(ZIP_EXTRA_HEADER)) &&
                (mi.signature == 'JLEE')) {
                gostCreator = mi.finfo.fdCreator;
                gostType = mi.finfo.fdType;
                fDataFork = (mi.flags & 1) ? TRUE : FALSE;
                fMacZipped = true;
                /* If it was Zipped w/Mac version, the filename has either */
                /* a 'd' or 'r' appended.  Remove the d/r when unzipping */
                filename[0]-=1;
            }
        }
        if (!fMacZipped) {
            if (!aflag)
                gostType = gostCreator = '\?\?\?\?';
            else {
                gostCreator = CREATOR;
                gostType = 'TEXT';
            }
        }
        p2cstr(filename);

        if ((outfd = creat(filename, 0)) != -1) {
            if (fMacZipped) {
                c2pstr(filename);
                if (HFSFlag) {
                    HParamBlockRec   hpbr;

                    hpbr.fileParam.ioNamePtr = (StringPtr)filename;
                    hpbr.fileParam.ioVRefNum = gnVRefNum;
                    hpbr.fileParam.ioDirID = glDirID;
                    hpbr.fileParam.ioFlFndrInfo = mi.finfo;
                    hpbr.fileParam.ioFlCrDat = mi.lCrDat;
                    hpbr.fileParam.ioFlMdDat = mi.lMdDat;
                    err = PBHSetFInfo(&hpbr, 0);
                } else {
                    err = SetFInfo((StringPtr)filename , 0, &mi.finfo);
                }
                p2cstr(filename);
            }
            outfd = open(filename, (fDataFork) ? 1 : 2);
        }

        if (outfd == -1)
            return NULL;
        else
            return (FILE *)outfd;
    }





/***********************/
/* Function maccreat() */
/***********************/

short maccreat(char *sz, short nVRefNum, long lDirID, OSType ostCreator, OSType ostType)
{
    OSErr   err;
    Str255  st;
    FInfo   fi;

    c2pstr( sz );
    BlockMove( sz, st, sz[0]+1 );
    p2cstr( sz );
    if (HFSFlag)
    {
        err = HGetFInfo( nVRefNum, lDirID, st, &fi );
        if (err == fnfErr)
            err = HCreate( nVRefNum, lDirID, st, ostCreator, ostType );
        else if (err == noErr)
        {
            fi.fdCreator = ostCreator;
            fi.fdType = ostType;
            err = HSetFInfo( nVRefNum, lDirID, st, &fi );
        }
    }
    else
    {
        err = GetFInfo( st, nVRefNum, &fi );
        if (err == fnfErr)
            err = Create( st, nVRefNum, ostCreator, ostType );
        else if (err == noErr)
        {
            fi.fdCreator = ostCreator;
            fi.fdType = ostType;
            err = SetFInfo( st, nVRefNum, &fi );
        }
    }
    if (err == noErr)
        return noErr;
    else
        return -1;
}





/**********************/
/* Function macread() */
/**********************/

short macread(short nFRefNum, char *pb, unsigned cb)
{
    long    lcb = cb;

    (void)FSRead( nFRefNum, &lcb, pb );

    return (short)lcb;
}





/***********************/
/* Function macwrite() */
/***********************/

long macwrite(short nFRefNum, char *pb, unsigned cb)
{
    long    lcb = cb;

#ifdef THINK_C
    if ( (nFRefNum == 1) )
        screenDump( pb, lcb );
    else
#endif
        (void)FSWrite( nFRefNum, &lcb, pb );

    return (long)lcb;
}





/***********************/
/* Function macclose() */
/***********************/

short macclose(short nFRefNum)
{
    return FSClose( nFRefNum );
}





/***********************/
/* Function maclseek() */
/***********************/

long maclseek(short nFRefNum, long lib, short nMode)
{
    ParamBlockRec   pbr;

    if (nMode == SEEK_SET)
        nMode = fsFromStart;
    else if (nMode == SEEK_CUR)
        nMode = fsFromMark;
    else if (nMode == SEEK_END)
        nMode = fsFromLEOF;
    pbr.ioParam.ioRefNum = nFRefNum;
    pbr.ioParam.ioPosMode = nMode;
    pbr.ioParam.ioPosOffset = lib;
    (void)PBSetFPos(&pbr, 0);
    return pbr.ioParam.ioPosOffset;
}

#endif /* MACOS */