From 59a724bd4cc7a543686c633572510e6763b34d39 Mon Sep 17 00:00:00 2001
From: Ash Wolf <ninji@wuffs.org>
Date: Thu, 13 Oct 2022 15:30:47 +0100
Subject: fix issues in OSLib Memory and ErrMgr, fully match OSLib Files
---
command_line/CmdLine/Src/MacEmul/ErrMgr.c | 9 +-
command_line/CmdLine/Src/MacEmul/Files.c | 625 +++++++++++++++++++++++++++++-
command_line/CmdLine/Src/MacEmul/Memory.c | 38 +-
3 files changed, 637 insertions(+), 35 deletions(-)
(limited to 'command_line/CmdLine/Src')
diff --git a/command_line/CmdLine/Src/MacEmul/ErrMgr.c b/command_line/CmdLine/Src/MacEmul/ErrMgr.c
index 65bb89c..5fc621d 100644
--- a/command_line/CmdLine/Src/MacEmul/ErrMgr.c
+++ b/command_line/CmdLine/Src/MacEmul/ErrMgr.c
@@ -18,10 +18,11 @@ static const char *getsyserr(SInt16 msgNbr) {
case -52: return "Get file position error";
case -54: return "Invalid file access or invalid permissions";
case -61: return "Write permissions error";
- case -108: return "Null or invalid address detected";
- case -109: return "invalid handle detected";
- case -113: return "Directory not found";
- case -120: return "User cancelled";
+ case -108: return "Out of available memory or buffer size exceeded";
+ case -109: return "NULL or invalid address detected";
+ case -113: return "invalid handle detected";
+ case -120: return "Directory not found";
+ case -128: return "User cancelled";
case -192: return "Resource not found";
case -1302: return "Not a file";
case -1309: return "Seek position exceeds boundaries for filesystem";
diff --git a/command_line/CmdLine/Src/MacEmul/Files.c b/command_line/CmdLine/Src/MacEmul/Files.c
index 7216c6b..5246ee2 100644
--- a/command_line/CmdLine/Src/MacEmul/Files.c
+++ b/command_line/CmdLine/Src/MacEmul/Files.c
@@ -1,5 +1,7 @@
#include "mwcc_decomp.h"
+#define OPTION_ASSERT(cond) do { if (!(cond)) { printf("%s:%u: failed assertion\n", __FILE__, __LINE__); abort(); } } while(0)
+
typedef struct MacFileInfo {
UInt32 ioFlCrDat;
UInt32 ioFlMdDat;
@@ -9,141 +11,740 @@ typedef struct MacFileInfo {
SInt32 ioFlRPyLen;
SInt32 ioFlStBlk;
SInt32 ioFlRStBlk;
- SInt32 ioFlAttrib;
+ SInt8 ioFlAttrib;
} MacFileInfo;
static int OS_GetFileParamInfo(const OSSpec *spec, MacFileInfo *mfi, FInfo *fi) {
-
+ time_t crtm;
+ time_t chtm;
+ OSType ft;
+ OSType fc;
+ UInt32 ttime;
+ UInt32 dsize;
+ UInt32 rsize;
+ OSSpec rsrc;
+ int ref;
+ int err;
+ char buffer[32];
+ UInt32 count;
+ Boolean isopen;
+
+ if (mfi) {
+ OS_GetFileTime(spec, &crtm, &chtm);
+ OS_TimeToMac(crtm, &ttime);
+ mfi->ioFlCrDat = ttime;
+ OS_TimeToMac(chtm, &ttime);
+ mfi->ioFlMdDat = ttime;
+ }
+
+ err = OS_Open(spec, OSReadOnly, &ref);
+ if (err < 0)
+ return err;
+
+ count = sizeof(buffer);
+ if (OS_Read(ref, buffer, &count))
+ count = 0;
+
+ if (mfi) {
+ mfi->ioFlAttrib = OS_IsDir(spec) ? ioDirMask : 0;
+ OS_GetSize(ref, &dsize);
+ mfi->ioFlLgLen = mfi->ioFlPyLen = dsize;
+ mfi->ioFlStBlk = 0;
+ }
+
+ OS_Close(ref);
+
+ OS_GetMacFileTypeMagic(buffer, count, &ft);
+ fc = 'CWIE';
+ if (OS_UsingMacResourceForkInfo() && !OS_GetRsrcOSSpec(spec, &rsrc, 0) && !OS_Status(&rsrc)) {
+ isopen = OS_SearchMacResourceForkList(&rsrc, &ref);
+ if (isopen || !OS_Open(&rsrc, 0, &ref)) {
+ if (mfi) {
+ OS_GetSize(ref, &rsize);
+ mfi->ioFlRLgLen = mfi->ioFlRPyLen = rsize;
+ mfi->ioFlRStBlk = 0;
+ }
+ OS_GetMacResourceForkCreatorAndType(ref, &fc, &ft);
+ if (!isopen)
+ OS_Close(ref);
+ }
+ } else {
+ if (mfi) {
+ mfi->ioFlRPyLen = 0;
+ mfi->ioFlRLgLen = 0;
+ mfi->ioFlRStBlk = 0;
+ }
+ }
+
+ fi->fdType = ft;
+ fi->fdCreator = fc;
+ fi->fdFlags = OS_IsLink(spec) ? kIsAlias : 0;
+ fi->fdLocation.v = 0;
+ fi->fdLocation.h = 0;
+ fi->fdFldr = 0;
+ return 0;
}
static int OS_SetFileParamInfo(const OSSpec *spec, MacFileInfo *mfi, FInfo *fi) {
+ time_t crtm;
+ time_t chtm;
+ OSSpec rspec;
+ int ref;
+ Boolean isopen;
+
+ OS_MacToTime(mfi->ioFlCrDat, &crtm);
+ OS_MacToTime(mfi->ioFlMdDat, &chtm);
+ OS_SetFileTime(spec, &crtm, &chtm);
+
+ OS_SetMacFileType(spec, fi->fdType);
+
+ if (OS_UsingMacResourceForkInfo() && !OS_GetRsrcOSSpec(spec, &rspec, 0) && !OS_Status(&rspec)) {
+ isopen = OS_SearchMacResourceForkList(&rspec, &ref);
+ if (!isopen && OS_Open(&rspec, OSReadWrite, &ref))
+ return 0;
+ OS_SetMacResourceForkCreatorAndType(ref, fi->fdCreator, fi->fdType);
+ if (!isopen)
+ OS_Close(ref);
+ }
+ return 0;
}
OSErr HCreate(SInt16 volume, SInt32 dirid, ConstStr255Param fileName, OSType creator, OSType type) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(volume, dirid, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpCreate(&fss, creator, type, -1);
}
OSErr HOpen(SInt16 vRefNum, SInt32 dirID, ConstStr255Param fileName, SInt8 permission, SInt16 *refNum) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpOpenDF(&fss, permission, refNum);
}
OSErr HOpenDF(SInt16 vRefNum, SInt32 dirID, ConstStr255Param fileName, SInt8 permission, SInt16 *refNum) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpOpenDF(&fss, permission, refNum);
}
OSErr HDelete(SInt16 vRefNum, SInt32 dirID, ConstStr255Param fileName) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpDelete(&fss);
}
OSErr HRename(SInt16 vRefNum, SInt32 dirID, ConstStr255Param oldName, ConstStr255Param newName) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, oldName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpRename(&fss, newName);
}
OSErr HGetFInfo(SInt16 vRefNum, SInt32 dirID, ConstStr255Param fileName, FInfo *fndrInfo) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpGetFInfo(&fss, fndrInfo);
}
OSErr HSetFInfo(SInt16 vRefNum, SInt32 dirID, ConstStr255Param fileName, const FInfo *fndrInfo) {
+ FSSpec fss;
+ OSErr __err;
+ __err = FSMakeFSSpec(vRefNum, dirID, fileName, &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+ return FSpSetFInfo(&fss, fndrInfo);
}
OSErr FSpCreate(const FSSpec *fss, OSType creator, OSType fileType, ScriptCode scriptTag) {
+ int err;
+ OSSpec spec;
+ FInfo finfo;
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+
+ if (!OS_Status(&spec))
+ return dupFNErr;
+
+ err = OS_Create(&spec, &OS_TEXTTYPE);
+ if (err)
+ return OS_MacError(err);
+
+ memset(&finfo, 0, sizeof(FInfo));
+ finfo.fdType = fileType;
+ finfo.fdCreator = creator;
+ FSpSetFInfo(fss, &finfo);
+ return 0;
}
OSErr FSpDirCreate(const FSSpec *fss, ScriptCode scriptTag, SInt32 *createdDirID) {
+ int err;
+ OSSpec spec;
+
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+
+ err = OS_Mkdir(&spec);
+ if (err)
+ return OS_MacError(err);
+ return 0;
}
OSErr FSpOpenDF(const FSSpec *fss, SInt8 permission, SInt16 *refNum) {
+ static OSOpenMode MacOpens[5] = {
+ OSReadWrite, OSReadOnly, OSWrite, OSReadWrite, OSReadWrite
+ };
+ OSSpec spec;
+ int err;
+ int ref;
+
+ *refNum = 0;
+
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+
+ if (OS_IsDir(&spec))
+ return dirNFErr;
+
+ err = OS_Open(&spec, MacOpens[permission], &ref);
+ if (err)
+ return OS_MacError(err);
+
+ *refNum = OS_RefToMac(ref);
+ return 0;
}
OSErr FSpDelete(const FSSpec *fss) {
+ OSSpec spec;
+ OSSpec rspec;
+ int err;
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+
+ err = OS_Delete(&spec);
+ if (!OS_GetRsrcOSSpec(&spec, &rspec, 0)) {
+ err = OS_Delete(&rspec);
+ OS_CleanupMacResourceForkDir(&rspec.path);
+ }
+ return OS_MacError(err);
}
OSErr FSpRename(const FSSpec *oldfss, ConstStr255Param newName) {
+ FSSpec newfss;
+ OSSpec oldspec;
+ OSSpec newspec;
+ OSSpec oldrspec;
+ OSSpec newrspec;
+ int err;
+
+ err = OS_FSSpec_To_OSSpec(oldfss, &oldspec);
+ if (err)
+ return OS_MacError(err);
+
+ newfss.vRefNum = oldfss->vRefNum;
+ newfss.parID = oldfss->parID;
+ _pstrcpy(newfss.name, newName);
+ err = OS_FSSpec_To_OSSpec(&newfss, &newspec);
+ if (err)
+ return OS_MacError(err);
+
+ err = OS_Rename(&oldspec, &newspec);
+ if (!OS_GetRsrcOSSpec(&oldspec, &oldrspec, 0)) {
+ OS_GetRsrcOSSpec(&newspec, &newrspec, 0);
+ err = OS_Rename(&oldrspec, &newrspec);
+ }
+ return OS_MacError(err);
}
OSErr FSpGetFInfo(const FSSpec *fss, FInfo *fndrInfo) {
+ int err;
+ OSSpec spec;
+ FInfo fi;
+
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+ err = OS_GetFileParamInfo(&spec, 0, &fi);
+ if (err)
+ return OS_MacError(err);
+
+ memcpy(fndrInfo, &fi, sizeof(FInfo));
+ return 0;
}
OSErr FSpSetFInfo(const FSSpec *fss, const FInfo *fndrInfo) {
+ HParamBlockRec hpb;
+ OSErr err;
+ Str255 fname;
+
+ _pstrcpy(fname, fss->name);
+ hpb.fileParam.ioVRefNum = fss->vRefNum;
+ hpb.fileParam.ioDirID = fss->parID;
+ hpb.fileParam.ioNamePtr = fname;
+ hpb.fileParam.ioFDirIndex = 0;
+ err = PBHGetFInfoSync(&hpb);
+ if (!err) {
+ hpb.fileParam.ioFlFndrInfo = *fndrInfo;
+ err = PBHSetFInfoSync(&hpb);
+ }
+ return err;
}
OSErr HGetVol(StringPtr volName, SInt16 *vRefNum, SInt32 *dirID) {
-
+ OSSpec spec;
+ int err;
+ FSSpec fss;
+ char vn[256];
+
+ if (volName && volName[0]) {
+ p2cstrcpy(vn, volName);
+ err = OS_MakePathSpec(vn, 0, &spec.path);
+ if (err)
+ return OS_MacError(err);
+ } else {
+ err = OS_MakePathSpec(0, 0, &spec.path);
+ if (err)
+ return OS_MacError(err);
+ }
+
+ OS_MakeNameSpec("", &spec.name);
+ err = OS_OSSpec_To_FSSpec(&spec, &fss);
+ if (err)
+ return OS_MacError(err);
+
+ *vRefNum = fss.vRefNum;
+ *dirID = fss.parID;
+ return 0;
}
OSErr HSetVol(ConstStr63Param volName, SInt16 vRefNum, SInt32 dirID) {
+ FSSpec fss;
+ int err;
+ OSSpec spec;
+ OSErr __err;
+
+ __err = FSMakeFSSpec(vRefNum, dirID, volName ? volName : "\p", &fss);
+ if (__err && __err != fnfErr)
+ return __err;
+
+ err = OS_FSSpec_To_OSSpec(&fss, &spec);
+ if (err)
+ return OS_MacError(err);
+ return OS_MacError(OS_Chdir(&spec.path));
}
OSErr FlushVol(ConstStr63Param volName, SInt16 vRefNum) {
-
+ return 0;
}
OSErr FSRead(SInt16 fRefNum, SInt32 *Size, void *Buffer) {
+ if (fRefNum == 0)
+ return rfNumErr;
+ return OS_MacError(OS_Read(OS_MacToRef(fRefNum), Buffer, (UInt32 *) Size));
}
OSErr FSWrite(SInt16 fRefNum, SInt32 *Size, const void *Buffer) {
+ if (fRefNum == 0)
+ return rfNumErr;
+ return OS_MacError(OS_Write(OS_MacToRef(fRefNum), Buffer, (UInt32 *) Size));
}
OSErr FSClose(SInt16 fRefNum) {
-
+ OSErr err;
+ OSSpec *rspec;
+ int ref;
+ UInt32 size;
+ int oerr;
+
+ if (fRefNum == 0)
+ return rfNumErr;
+
+ ref = OS_MacToRef(fRefNum);
+ rspec = OS_GetMacResourceForkFromRef(ref);
+ if (rspec) {
+ oerr = OS_GetSize(ref, &size);
+ err = OS_MacError(OS_Close(ref));
+ if (!oerr && !size) {
+ OS_Delete(rspec);
+ OS_CleanupMacResourceForkDir(&rspec->path);
+ }
+ OS_RemoveMacResourceForkRef(ref);
+ } else {
+ err = OS_MacError(OS_Close(ref));
+ }
+
+ return err;
}
OSErr GetEOF(SInt16 fRefNum, SInt32 *curEOF) {
+ if (fRefNum == 0)
+ return rfNumErr;
+ return OS_MacError(OS_GetSize(OS_MacToRef(fRefNum), (UInt32 *) curEOF));
}
OSErr SetEOF(SInt16 fRefNum, SInt32 newEOF) {
+ if (fRefNum == 0)
+ return rfNumErr;
+ return OS_MacError(OS_SetSize(OS_MacToRef(fRefNum), newEOF));
}
OSErr GetFPos(SInt16 fRefNum, SInt32 *pos) {
+ if (fRefNum == 0)
+ return rfNumErr;
+ return OS_MacError(OS_Tell(OS_MacToRef(fRefNum), pos));
}
-OSErr SetFPos(SInt16 fRefNum, SInt16 posMode, SInt32 posOffset) {
+static OSSeekMode MacSeek[4] = {
+ OSSeekAbs, OSSeekAbs, OSSeekEnd, OSSeekRel
+};
+OSErr SetFPos(SInt16 fRefNum, SInt16 posMode, SInt32 posOffset) {
+ SInt32 pos;
+ SInt32 npos;
+ UInt32 size;
+ int err;
+ int ref;
+
+ ref = OS_MacToRef(fRefNum);
+ if (fRefNum == 0)
+ return rfNumErr;
+
+ if (posMode & 3) {
+ err = OS_Tell(ref, &pos);
+ if (err)
+ return OS_MacError(err);
+
+ err = OS_GetSize(ref, &size);
+ if (err)
+ return OS_MacError(err);
+
+ if ((posMode & 3) == fsFromStart) {
+ npos = posOffset;
+ } else if ((posMode & 3) == fsFromLEOF) {
+ npos = size + posOffset;
+ } else if ((posMode & 3) == fsFromMark) {
+ npos = pos + posOffset;
+ } else {
+ return paramErr;
+ }
+
+ err = OS_Seek(ref, OSSeekAbs, npos);
+ if (err)
+ return OS_MacError(err);
+
+ if (npos > size) {
+ OS_Seek(ref, OSSeekAbs, pos);
+ return eofErr;
+ }
+ }
+
+ return 0;
}
OSErr GetVInfo(SInt16 vRefNum, StringPtr name, SInt16 *vRef, SInt32 *hDir) {
+ int err;
+ OSNameSpec spec;
+ SInt32 parID;
+
+ *vRef = 0;
+ *hDir = 0;
+ err = OS_VolDir_To_OSNameSpec(vRefNum, 2, &spec, &parID);
+ if (!err) {
+ OS_NameSpecToString(&spec, (char *) name, 256);
+ c2pstr((char *) name);
+ _pstrcharcat(name, OS_PATHSEP);
+ return 0;
+ } else {
+ return OS_MacError(err);
+ }
}
OSErr PBWriteSync(ParmBlkPtr paramBlock) {
-
+ int err;
+ int ref;
+
+ ref = OS_MacToRef(paramBlock->ioParam.ioRefNum);
+ if (!paramBlock->ioParam.ioRefNum) {
+ return (paramBlock->ioParam.ioResult = rfNumErr);
+ } else {
+ if (paramBlock->ioParam.ioPosMode & 3) {
+ err = OS_Seek(ref, MacSeek[paramBlock->ioParam.ioPosMode & 3], paramBlock->ioParam.ioPosOffset);
+ if (err)
+ return (paramBlock->ioParam.ioResult = OS_MacError(err));
+ }
+ paramBlock->ioParam.ioActCount = paramBlock->ioParam.ioReqCount;
+ err = OS_Write(ref, paramBlock->ioParam.ioBuffer, (UInt32 *) ¶mBlock->ioParam.ioActCount);
+ return (paramBlock->ioParam.ioResult = OS_MacError(err));
+ }
}
OSErr PBHGetFInfoSync(HParmBlkPtr paramBlock) {
-
+ HFileParam fp;
+ FSSpec fss;
+ OSErr err;
+ int oserr;
+ OSSpec spec;
+ MacFileInfo mfi;
+ FInfo fi;
+
+ memcpy(&fp, ¶mBlock->fileParam, sizeof(HFileParam));
+ err = FSMakeFSSpec(fp.ioVRefNum, fp.ioDirID, (fp.ioFDirIndex != -1) ? fp.ioNamePtr : "\p", &fss);
+ if (!err) {
+ oserr = OS_FSSpec_To_OSSpec(&fss, &spec);
+ if (!oserr) {
+ OS_GetFileParamInfo(&spec, &mfi, &fi);
+ fp.ioFlCrDat = mfi.ioFlCrDat;
+ fp.ioFlMdDat = mfi.ioFlMdDat;
+ fp.ioFlLgLen = mfi.ioFlLgLen;
+ fp.ioFlPyLen = mfi.ioFlPyLen;
+ fp.ioFlRLgLen = mfi.ioFlRLgLen;
+ fp.ioFlRPyLen = mfi.ioFlRPyLen;
+ fp.ioFlAttrib = mfi.ioFlAttrib;
+ memcpy(&fp.ioFlFndrInfo, &fi, sizeof(FInfo));
+ } else {
+ memset(&fp, 0, sizeof(fp));
+ }
+ }
+
+ fp.ioResult = err;
+ memcpy(¶mBlock->fileParam, &fp, sizeof(HFileParam));
+ return err;
}
OSErr PBHSetFInfoSync(HParmBlkPtr paramBlock) {
-
+ HFileParam fp;
+ FInfo *pfi;
+ FSSpec fss;
+ OSErr err;
+ int oserr;
+ OSSpec spec;
+ MacFileInfo mfi;
+ FInfo fi;
+
+ pfi = &fp.ioFlFndrInfo;
+ memcpy(&fp, ¶mBlock->fileParam, sizeof(HFileParam));
+ err = FSMakeFSSpec(fp.ioVRefNum, fp.ioDirID, fp.ioNamePtr, &fss);
+ if (!err) {
+ oserr = OS_FSSpec_To_OSSpec(&fss, &spec);
+ if (!oserr) {
+ memcpy(&fi, pfi, sizeof(FInfo));
+ memset(&mfi, 0, sizeof(mfi));
+ mfi.ioFlCrDat = fp.ioFlCrDat;
+ mfi.ioFlMdDat = fp.ioFlMdDat;
+ oserr = OS_SetFileParamInfo(&spec, &mfi, &fi);
+ }
+ err = OS_MacError(oserr);
+ }
+
+ fp.ioResult = err;
+ memcpy(¶mBlock->fileParam, &fp, sizeof(HFileParam));
+ return err;
}
OSErr PBGetCatInfoSync(CInfoPBPtr paramBlock) {
-
+ OSErr err;
+ FSSpec fss;
+ OSSpec spec;
+ int oserr;
+ HFileInfo hfi;
+ MacFileInfo mfi;
+ FInfo fi;
+ char tmp[64];
+
+ memcpy(&hfi, ¶mBlock->hFileInfo, sizeof(HFileInfo));
+ err = FSMakeFSSpec(hfi.ioVRefNum, hfi.ioDirID, (hfi.ioFDirIndex > 0) ? hfi.ioNamePtr : "\p", &fss);
+ if (!err) {
+ oserr = OS_FSSpec_To_OSSpec(&fss, &spec);
+ if (!oserr) {
+ OS_VolDir_To_OSNameSpec(hfi.ioVRefNum, hfi.ioDirID, &spec.name, &hfi.ioFlParID);
+ if (hfi.ioNamePtr) {
+ OS_NameSpecToString(&spec.name, tmp, 256);
+ c2pstrcpy(hfi.ioNamePtr, tmp);
+ }
+ oserr = OS_GetFileParamInfo(&spec, &mfi, &fi);
+ if (!oserr) {
+ hfi.ioFlCrDat = mfi.ioFlCrDat;
+ hfi.ioFlMdDat = mfi.ioFlMdDat;
+ hfi.ioFlLgLen = mfi.ioFlLgLen;
+ hfi.ioFlPyLen = mfi.ioFlPyLen;
+ hfi.ioFlRLgLen = mfi.ioFlRLgLen;
+ hfi.ioFlRPyLen = mfi.ioFlRPyLen;
+ hfi.ioFlStBlk = mfi.ioFlRStBlk;
+ hfi.ioFlRStBlk = mfi.ioFlRStBlk;
+ hfi.ioFlAttrib = mfi.ioFlAttrib;
+ memcpy(&hfi.ioFlFndrInfo, &fi, sizeof(FInfo));
+ }
+ }
+ err = OS_MacError(err);
+ }
+
+ hfi.ioResult = err;
+ memcpy(¶mBlock->hFileInfo, &hfi, sizeof(HFileInfo));
+ return hfi.ioResult;
}
OSErr ResolveAliasFile(FSSpec *fss, Boolean resolveChains, Boolean *isFolder, Boolean *wasAliased) {
+ OSSpec spec;
+ int err;
+
+ *isFolder = 0;
+ *wasAliased = 0;
+ err = OS_FSSpec_To_OSSpec(fss, &spec);
+ if (err)
+ return OS_MacError(err);
+
+ *wasAliased = 0;
+ while (OS_IsLink(&spec)) {
+ *wasAliased = 1;
+ OS_ResolveLink(&spec, &spec);
+ if (!resolveChains)
+ break;
+ }
+
+ *isFolder = OS_IsDir(&spec);
+ err = OS_OSSpec_To_FSSpec(&spec, fss);
+ if (err)
+ return OS_MacError(err);
+
+ return 0;
}
OSErr FSMakeFSSpec(SInt16 vRefNum, SInt32 dirID, ConstStr255Param pathName, FSSpec *fss) {
-
+ OSSpec spec;
+ int err;
+ char path[256];
+ FSSpec tmpfss;
+ int idx;
+ char *pptr;
+ char vol[8];
+ char *nmptr;
+ int len;
+
+ fss->vRefNum = 0;
+ fss->parID = 0;
+
+ if (!vRefNum && !dirID) {
+ err = OS_GetCWD(&spec.path);
+ if (err) {
+ fss->name[0] = 0;
+ return OS_MacError(err);
+ }
+ OS_PathSpecToString(&spec.path, path, 256);
+ } else {
+#line 840
+ OPTION_ASSERT(vRefNum!=0);
+ tmpfss.vRefNum = vRefNum;
+ tmpfss.parID = dirID ? dirID : 2;
+ tmpfss.name[0] = 0;
+ err = OS_FSSpec_To_OSSpec(&tmpfss, &spec);
+ if (err) {
+ fss->name[0] = 0;
+ return OS_MacError(err);
+ }
+ OS_PathSpecToString(&spec.path, path, 256);
+ }
+
+ if (pstrchr(pathName, ':')) {
+ idx = 1;
+ if (pathName[1] != ':') {
+ while (idx <= pathName[0]) {
+ if (pathName[idx] == ':')
+ break;
+ vol[idx - 1] = pathName[idx];
+ idx++;
+ if (idx >= 8) {
+ fss->name[0] = 0;
+ return nsvErr;
+ }
+ }
+ vol[idx - 1] = 0;
+ idx++;
+ if (!OS_MakePathSpec(vol, 0, &spec.path)) {
+ OS_PathSpecToString(&spec.path, path, 256);
+ } else {
+ c2pstrcpy(fss->name, vol);
+ return nsvErr;
+ }
+ }
+
+ pptr = path + strlen(path);
+ while (idx <= pathName[0]) {
+ if (pathName[idx] == ':') {
+ if (idx < pathName[0] && pathName[idx + 1] == ':') {
+ do {
+ pptr += sprintf(pptr, "../");
+ } while (++idx < pathName[0] && pathName[idx + 1] == ':');
+ } else {
+ *(pptr++) = OS_PATHSEP;
+ }
+ } else {
+ *(pptr++) = pathName[idx];
+ }
+ ++idx;
+ }
+ *pptr = 0;
+ } else {
+ p2cstrcpy(path + strlen(path), pathName);
+ }
+
+ err = OS_MakeSpec(path, &spec, 0);
+ if (!err) {
+ OS_OSSpec_To_FSSpec(&spec, fss);
+ return OS_MacError(OS_Status(&spec));
+ } else {
+ nmptr = OS_GetFileNamePtr(path);
+ len = strlen(nmptr);
+ if (len >= sizeof(fss->name))
+ len = 255;
+ fss->name[0] = len;
+ memcpy(&fss->name[1], nmptr, len);
+ return OS_MacError(err);
+ }
}
OSErr Allocate(SInt16 refNum, SInt32 *byteCount) {
-
+ return SetEOF(refNum, *byteCount);
}
diff --git a/command_line/CmdLine/Src/MacEmul/Memory.c b/command_line/CmdLine/Src/MacEmul/Memory.c
index 8b956a0..0aa5d24 100644
--- a/command_line/CmdLine/Src/MacEmul/Memory.c
+++ b/command_line/CmdLine/Src/MacEmul/Memory.c
@@ -14,13 +14,13 @@ OSHandle *OS_PeekMacHandle(Handle h) {
}
static void FixHandlePtr(Handle h, void *ptr) {
- HS(h)->hand.addr = ptr;
+ HS(h)->addr = ptr;
}
Handle OS_CreateMacHandle(OSHandle *h) {
HandleStructure *hs = malloc(sizeof(HandleStructure));
if (!hs) {
- memError = -108;
+ memError = memFullErr;
return 0;
};
@@ -34,7 +34,7 @@ Handle OS_CreateMacHandle(OSHandle *h) {
Handle OS_CreateMacHandleDup(OSHandle *h) {
HandleStructure *hs = malloc(sizeof(HandleStructure));
if (!hs) {
- memError = -108;
+ memError = memFullErr;
return 0;
};
@@ -45,7 +45,7 @@ Handle OS_CreateMacHandleDup(OSHandle *h) {
}
void OS_DestroyMacHandle(Handle h, OSHandle *ret) {
- *ret = HS(h)->hand;
+ *ret = *OS_PeekMacHandle(h);
free(h);
}
@@ -80,8 +80,10 @@ Handle NewHandleClear(UInt32 dataSize) {
}
Handle TempNewHandle(UInt32 dataSize, OSErr *resultCode) {
+ Handle hdl;
+
*resultCode = 0;
- Handle hdl = NewHandle(dataSize);
+ hdl = NewHandle(dataSize);
if (!hdl)
*resultCode = memError;
return hdl;
@@ -92,7 +94,7 @@ void DisposeHandle(Handle h) {
memError = OS_MacError(OS_FreeHandle(&HS(h)->hand));
FixHandlePtr(h, 0);
} else {
- memError = -109;
+ memError = nilHandleErr;
}
}
@@ -104,7 +106,7 @@ void HLock(Handle h) {
FixHandlePtr(h, buffer);
memError = 0;
} else {
- memError = -109;
+ memError = nilHandleErr;
}
}
@@ -117,7 +119,7 @@ void HUnlock(Handle h) {
memError = 0;
OS_UnlockHandle(&HS(h)->hand);
} else {
- memError = -109;
+ memError = nilHandleErr;
}
}
@@ -145,7 +147,7 @@ SInt32 GetHandleSize(Handle h) {
memError = OS_MacError(OS_GetHandleSize(&HS(h)->hand, &sz));
} else {
sz = 0;
- memError = -109;
+ memError = nilHandleErr;
}
return sz;
@@ -161,15 +163,14 @@ OSErr PtrAndHand(const void *srcPtr, Handle destHandle, SInt32 size) {
OSErr err;
err = OS_MacError(OS_AppendHandle(&HS(destHandle)->hand, srcPtr, size));
- FixHandlePtr(h, OS_LockHandle(&HS(destHandle)->hand));
- OS_UnlockHandle(&HS(h)->hand);
+ FixHandlePtr(destHandle, OS_LockHandle(&HS(destHandle)->hand));
+ OS_UnlockHandle(&HS(destHandle)->hand);
return err;
}
OSErr PtrToHand(const void *srcPtr, Handle *destHandle, SInt32 size) {
- *destHandle = NewHandle(size);
- if (!*destHandle)
+ if (!(*destHandle = NewHandle(size)))
return MemError();
HLock(*destHandle);
@@ -184,8 +185,7 @@ OSErr HandToHand(Handle *destHandle) {
SInt32 size;
size = GetHandleSize(srcHandle);
- *destHandle = NewHandle(size);
- if (!*destHandle)
+ if (!(*destHandle = NewHandle(size)))
return MemError();
HLock(*destHandle);
@@ -209,7 +209,7 @@ OSErr HandAndHand(Handle src, Handle dst) {
}
void MoveHHi(Handle theHandle) {
- memError = theHandle ? 0 : -109;
+ memError = theHandle ? noErr : nilHandleErr;
}
void BlockMove(const void *srcPtr, void *destPtr, UInt32 byteCount) {
@@ -227,7 +227,7 @@ Ptr NewPtr(SInt32 dataSize) {
dataSize = 1;
p = malloc(dataSize);
- memError = p ? 0 : -108;
+ memError = p ? noErr : memFullErr;
return p;
}
@@ -240,7 +240,7 @@ void DisposePtr(Ptr p) {
Ptr NewPtrClear(SInt32 dataSize) {
Ptr p;
- memError = -108;
+ memError = memFullErr;
if (!dataSize)
dataSize = 1;
@@ -254,7 +254,7 @@ Ptr NewPtrClear(SInt32 dataSize) {
}
void DebugStr(ConstStringPtr str) {
- fprintf(stderr, "*.*s", str[0], str[1], &str[1]);
+ fprintf(stderr, "%*.*s", str[0], str[0], &str[1]);
}
struct Zone *HandleZone() {
--
cgit v1.2.3