mpw/toolbox/rm.cpp

1158 lines
24 KiB
C++
Raw Normal View History

2013-07-30 05:06:19 +00:00
/*
* Copyright (c) 2013, Kelvin W Sherlock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
2013-02-21 04:28:55 +00:00
#include <string>
//#include <unordered_map>
#include <list>
2013-06-27 03:24:20 +00:00
#include <map>
2013-02-21 04:28:55 +00:00
#include <CoreServices/CoreServices.h>
2013-02-07 04:44:12 +00:00
#include "rm.h"
2013-02-14 04:07:33 +00:00
#include "toolbox.h"
2013-02-19 23:28:58 +00:00
#include "mm.h"
2013-06-24 00:42:16 +00:00
#include "os_internal.h"
2013-02-07 04:44:12 +00:00
#include <cpu/defs.h>
#include <cpu/CpuModule.h>
#include <cpu/fmem.h>
2013-05-13 02:36:22 +00:00
#include <macos/sysequ.h>
2013-06-24 00:42:16 +00:00
#include <macos/errors.h>
2014-12-22 03:30:04 +00:00
#include <macos/tool_return.h>
2013-02-21 04:28:55 +00:00
2013-02-16 01:42:20 +00:00
#include "stackframe.h"
2014-12-16 18:07:51 +00:00
#include "fs_spec.h"
2013-02-16 23:51:28 +00:00
using ToolBox::Log;
2013-06-24 00:42:16 +00:00
using namespace OS::Internal;
2014-07-24 17:40:57 +00:00
using namespace ToolBox;
2013-06-24 00:42:16 +00:00
2014-12-20 17:20:34 +00:00
using MacOS::tool_return;
2014-12-21 00:32:54 +00:00
using MacOS::macos_error_from_errno;
2014-12-22 03:30:04 +00:00
using MacOS::macos_error;
2014-12-20 17:20:34 +00:00
2013-02-19 23:28:58 +00:00
namespace
{
2013-06-30 17:12:27 +00:00
bool ResLoad = true;
2013-02-21 04:28:55 +00:00
#if 0
struct ResEntry
{
ResEntry(uint32_t type = 0, uint32_t id = 0) :
resType(type), resID(id)
{}
uint32_t resType;
uint32_t resID;
uint32_t handle;
};
std::list<ResEntry> ResourceMapList;
#endif
// sigh... really need to create a resmap for every open
// resource file and update that with the pointer.
2013-06-27 03:24:20 +00:00
std::map<uint32_t, Handle> rhandle_map;
2013-02-26 23:33:21 +00:00
inline uint16_t SetResError(uint16_t error)
{
2013-05-13 02:36:22 +00:00
memoryWriteWord(error, MacOS::ResErr);
2013-02-26 23:33:21 +00:00
return error;
}
2013-06-28 00:27:55 +00:00
bool LoadResType(uint32_t type)
{
2013-08-16 03:36:26 +00:00
// this filtering was originally to
// block cursors ('acur'). Can probably
// change it to a blacklist rather than
// a whitelist at some point.
2013-06-28 00:27:55 +00:00
switch (type)
{
case 0x76657273: // 'vers';
case 0x48455841: // 'HEXA'
case 0x53545220: // 'STR '
case 0x53545223: // 'STR#' (reziigs)
case 0x59414343: // 'YACC' (pascaliigs)
case 0x72547970: // 'rTyp' (rezIIgs)
case 0x756e6974: // 'unit' (Pascal)
case 0x434f4445: // 'CODE' (Link)
2013-06-30 17:13:02 +00:00
case 0x5041434b: // 'PACK' (PascalIIgs)
2013-08-16 03:36:26 +00:00
case 0x4b4f4445: // 'KODE' (Link 32-bit Startup)
2014-12-20 17:20:34 +00:00
case 0x45525253: // 'ERRS' (PPCLink)
case 0x63667267: // 'cfrg' (PPCLink)
2015-01-09 17:45:03 +00:00
case 0x44415441: // 'DATA' (MetroWerks tools)
case 0x54455854: // 'TEXT' (MetroWerks tools)
case 0x6f626a64: // 'objd' (MetroWerks tools)
2013-06-28 00:27:55 +00:00
return true;
default:
return false;
}
}
2013-02-21 04:28:55 +00:00
2013-03-27 03:54:08 +00:00
}
namespace RM
{
2013-02-21 04:28:55 +00:00
2013-06-28 00:27:55 +00:00
2013-03-27 03:54:08 +00:00
namespace Native
{
2013-02-21 04:28:55 +00:00
2013-08-03 23:19:44 +00:00
// not to be confused with MacOS LoadResource(theHandle)
2013-06-28 00:27:55 +00:00
template<class FX>
uint16_t LoadResource(uint32_t type, uint32_t &theHandle, FX fx)
2013-03-27 03:54:08 +00:00
{
uint32_t ptr;
uint16_t error;
Handle nativeHandle;
uint32_t size;
theHandle = 0;
2013-06-28 00:27:55 +00:00
if (!LoadResType(type))
return SetResError(resNotFound);
nativeHandle = fx();
2013-03-27 03:54:08 +00:00
if (!nativeHandle) return SetResError(resNotFound);
2013-06-30 17:12:27 +00:00
// in OS X 10.8, ::SetResLoad(false) seems to be permanent.
// therefore, explicitly load it if needed. (PascalIIgs)
if (ResLoad) ::LoadResource(nativeHandle);
2013-03-27 03:54:08 +00:00
size = ::GetHandleSize(nativeHandle);
error = MM::Native::NewHandle(size, false, theHandle, ptr);
2013-08-16 03:36:26 +00:00
// TODO -- need to lock if native handle locked.
2013-03-27 03:54:08 +00:00
if (!theHandle)
{
::ReleaseResource(nativeHandle);
2013-06-28 00:27:55 +00:00
return SetResError(error);
2013-03-27 03:54:08 +00:00
}
2013-08-03 23:17:15 +00:00
MM::Native::HSetRBit(theHandle);
2013-03-27 03:54:08 +00:00
2013-06-28 00:27:55 +00:00
if (size)
std::memcpy(memoryPointer(ptr), *(void **)nativeHandle, size);
2013-03-27 03:54:08 +00:00
2013-06-28 00:27:55 +00:00
//::ReleaseResource(nativeHandle);
rhandle_map.insert({theHandle, nativeHandle});
return SetResError(0);
}
// used by GetString (utility.h)
2013-08-17 22:59:03 +00:00
// used by Loader.
2013-06-28 00:27:55 +00:00
uint16_t GetResource(uint32_t type, uint16_t id, uint32_t &theHandle)
{
return LoadResource(type, theHandle,
[type, id](){
return ::GetResource(type, id);
});
2013-03-27 03:54:08 +00:00
}
2013-02-21 04:28:55 +00:00
2013-08-17 22:59:03 +00:00
uint16_t SetResLoad(bool load)
{
ResLoad = load;
::SetResLoad(load);
memoryWriteByte(load ? 0xff : 0x00, MacOS::ResLoad); // word or byte?
return SetResError(0);
}
2013-02-21 04:28:55 +00:00
}
2013-02-26 23:33:21 +00:00
uint16_t CloseResFile(uint16_t trap)
{
2014-12-24 15:17:23 +00:00
// PROCEDURE CloseResFile (refNum: Integer);
2013-02-26 23:33:21 +00:00
uint16_t refNum;
StackFrame<2>(refNum);
Log("%04x CloseResFile(%04x)\n", trap, refNum);
2014-12-24 15:17:23 +00:00
// If the value of the refNum parameter is 0, it represents the System file and is ignored.
2013-06-25 02:53:17 +00:00
2014-12-24 15:17:23 +00:00
if (refNum != 0)
{
::CloseResFile(refNum);
return SetResError(::ResError());
}
return SetResError(0);
2013-06-25 02:53:17 +00:00
//return SetResError(resFNotFound);
2013-02-26 23:33:21 +00:00
}
2013-02-08 03:12:30 +00:00
uint16_t Get1NamedResource(uint16_t trap)
2013-02-07 04:44:12 +00:00
{
// Get1NamedResource (theType: ResType; name: Str255) : Handle;
/*
* -----------
* +8 outHandle
* ------------
* +4 theType
* ------------
* +0 name
* ------------
*
*/
// nb - return address is not on the stack.
uint32_t sp;
uint32_t theType;
uint32_t name;
2013-02-16 01:42:20 +00:00
sp = StackFrame<8>(theType, name);
2013-02-07 04:44:12 +00:00
2013-02-14 04:07:33 +00:00
std::string sname = ToolBox::ReadPString(name);
2013-02-07 04:44:12 +00:00
2013-08-18 04:33:03 +00:00
Log("%04x Get1NamedResource(%08x ('%s'), %s)\n",
trap, theType, TypeToString(theType).c_str(), sname.c_str());
2013-02-07 04:44:12 +00:00
2013-06-28 00:27:55 +00:00
uint32_t resourceHandle;
uint32_t d0;
d0 = Native::LoadResource(theType, resourceHandle,
[theType, name](){
return ::Get1NamedResource(theType, memoryPointer(name));
}
);
2013-02-26 23:30:25 +00:00
ToolReturn<4>(sp, resourceHandle);
2013-06-28 00:27:55 +00:00
return SetResError(d0);
2013-02-07 04:44:12 +00:00
}
2013-02-14 04:07:33 +00:00
2013-02-19 23:28:58 +00:00
2013-02-14 04:07:33 +00:00
uint16_t GetResource(uint16_t trap)
{
// GetResource (theType: ResType; theID: Integer): Handle;
/*
* -----------
* +6 outHandle
* ------------
* +2 theType
* ------------
* +0 theID
* ------------
*
*/
// nb - return address is not on the stack.
uint32_t sp;
uint32_t theType;
uint16_t theID;
2013-02-21 04:28:55 +00:00
2013-02-16 01:42:20 +00:00
sp = StackFrame<6>(theType, theID);
2013-02-14 04:07:33 +00:00
2013-07-08 03:40:51 +00:00
Log("%04x GetResource(%08x ('%s'), %04x)\n",
trap, theType, TypeToString(theType).c_str(), theID);
2013-02-19 23:28:58 +00:00
2013-02-21 04:28:55 +00:00
2013-06-28 00:27:55 +00:00
uint32_t resourceHandle;
uint32_t d0;
d0 = Native::LoadResource(theType, resourceHandle,
[theType, theID](){
return ::GetResource(theType, theID);
}
);
2013-02-21 04:28:55 +00:00
ToolReturn<4>(sp, resourceHandle);
2013-03-27 03:54:08 +00:00
return d0;
2013-02-19 23:28:58 +00:00
}
2013-02-21 04:28:55 +00:00
2013-02-19 23:28:58 +00:00
uint16_t Get1Resource(uint16_t trap)
{
// Get1Resource (theType: ResType; theID: Integer): Handle;
/*
* -----------
* +6 outHandle
* ------------
* +2 theType
* ------------
* +0 theID
* ------------
*
*/
// nb - return address is not on the stack.
uint32_t sp;
uint32_t theType;
uint16_t theID;
sp = StackFrame<6>(theType, theID);
Log("%04x Get1Resource(%08x ('%s'), %04x)\n", trap, theType, TypeToString(theType).c_str(), theID);
2013-02-14 04:07:33 +00:00
2013-06-28 00:27:55 +00:00
uint32_t resourceHandle;
uint32_t d0;
d0 = Native::LoadResource(theType, resourceHandle,
[theType, theID](){
return ::Get1Resource(theType, theID);
}
);
2013-02-21 04:28:55 +00:00
ToolReturn<4>(sp, resourceHandle);
2013-03-27 03:54:08 +00:00
return d0;
2013-02-14 04:07:33 +00:00
}
2013-02-19 23:28:58 +00:00
uint16_t ReleaseResource(uint16_t trap)
{
// ReleaseResource (theResource: Handle);
/*
* ------------
* +0 theResource
* ------------
*
*/
2013-02-21 04:28:55 +00:00
uint32_t sp;
uint32_t theResource;
2013-02-19 23:28:58 +00:00
2013-02-21 04:28:55 +00:00
sp = StackFrame<4>(theResource);
2013-02-19 23:28:58 +00:00
2013-02-21 04:28:55 +00:00
Log("%04x ReleaseResource(%08x)\n", trap, theResource);
2013-02-19 23:28:58 +00:00
2013-02-26 23:33:21 +00:00
return SetResError(0);
}
uint16_t ResError(uint16_t trap)
{
uint32_t sp;
2013-02-26 23:33:21 +00:00
Log("%04x ResError()\n", trap);
sp = cpuGetAReg(7);
ToolReturn<2>(sp, memoryReadWord(MacOS::ResErr));
return 0;
2013-02-26 23:33:21 +00:00
}
// SetResLoad (load: BOOLEAN);
uint16_t SetResLoad(uint16_t trap)
{
uint16_t load;
StackFrame<2>(load);
Log("%04x SetResLoad(%04x)\n", trap, load);
2013-06-30 17:12:27 +00:00
ResLoad = load;
2013-06-28 00:27:55 +00:00
::SetResLoad(load);
2013-05-13 02:36:22 +00:00
memoryWriteByte(load ? 0xff : 0x00, MacOS::ResLoad); // word or byte?
2013-06-25 02:53:17 +00:00
return SetResError(0);
2013-02-19 23:28:58 +00:00
}
2013-02-26 23:33:21 +00:00
2013-03-03 01:53:54 +00:00
uint16_t CurResFile(uint16_t trap)
{
Log("%04x CurResFile()\n", trap);
ResFileRefNum refNum = ::CurResFile();
ToolReturn<2>(-1, refNum);
return SetResError(::ResError());
}
2013-03-04 02:55:33 +00:00
uint16_t UseResFile(uint16_t trap)
{
uint16_t resFile;
StackFrame<2>(resFile);
Log("%04x UseResFile(%04x)\n", trap, resFile);
::UseResFile(resFile);
return SetResError(::ResError());
}
2013-03-03 01:53:54 +00:00
2014-12-22 03:30:04 +00:00
tool_return<void> CreateResFile(const std::string &path)
{
if (path.empty()) return MacOS::paramErr;
FSRef ref;
OSErr error;
int fd;
error = ::FSPathMakeRef((const UInt8 *)path.c_str(), &ref, NULL);
if (error != noErr)
return macos_error(error);
// FSCreateResourceFork only works with existing files.
fd = ::open(path.c_str(), O_CREAT | O_EXCL | O_RDWR, 0666);
if (fd < 0)
{
if (errno != EEXIST) return macos_error_from_errno();
}
if (fd >= 0) close(fd);
HFSUniStr255 fork = {0,{0}};
::FSGetResourceForkName(&fork);
error = ::FSCreateResourceFork(&ref, fork.length, fork.unicode, 0);
return macos_error(error);
}
2013-06-24 00:42:16 +00:00
uint16_t CreateResFile(uint16_t trap)
{
// PROCEDURE CreateResFile (fileName: Str255);
/*
* CreateResFile creates a resource file containing no resource
* data. If there's no file at all with the given name, it also
* creates an empty data fork for the file. If there's already a
* resource file with the given name (that is, a resource fork
* that isn't empty), CreateResFile will do nothing and the
* ResError function will return an appropriate Operating System
* result code.
*/
// FSCreateResourceFile uses the parent FSRef + a file name.
uint32_t fileName;
FSRef ref;
OSErr error;
int fd;
StackFrame<4>(fileName);
std::string sname = ToolBox::ReadPString(fileName, true);
Log("%04x CreateResFile(%s)\n", trap, sname.c_str());
if (!sname.length()) return SetResError(MacOS::paramErr);
// 1. if the file exists, call FSCreateResourceFork on the file.
// 2. if the file does not exist, create the file then call
// FSCreateResourceFork
2013-06-25 02:53:17 +00:00
error = ::FSPathMakeRef((const UInt8 *)sname.c_str(), &ref, NULL);
2013-06-24 00:42:16 +00:00
if (error != noErr)
{
return SetResError(error);
}
2013-06-25 02:53:17 +00:00
fd = ::open(sname.c_str(), O_CREAT | O_EXCL | O_RDWR, 0666);
2013-06-24 00:42:16 +00:00
if (fd < 0)
{
2014-12-21 00:32:54 +00:00
if (errno != EEXIST) return SetResError(macos_error_from_errno());
2013-06-24 00:42:16 +00:00
}
if (fd >= 0) close(fd);
HFSUniStr255 fork = {0,{0}};
::FSGetResourceForkName(&fork);
2013-06-24 00:42:16 +00:00
2013-06-25 02:53:17 +00:00
error = ::FSCreateResourceFork(&ref, fork.length, fork.unicode, 0);
2013-06-24 00:42:16 +00:00
return SetResError(error);
}
2014-12-22 03:30:04 +00:00
uint16_t FSpCreateResFile(void)
{
// PROCEDURE FSpCreateResFile (spec: FSSpec; creator, fileType: OSType; scriptTag: ScriptCode);
// creates the file, if necessary.
uint32_t sp;
uint32_t spec;
uint32_t creator;
uint32_t fileType;
uint16_t scriptTag;
sp = StackFrame<14>(spec, creator, fileType, scriptTag);
int parentID = memoryReadLong(spec + 2);
std::string sname = ToolBox::ReadPString(spec + 6, false);
Log(" FSpCreateResFile(%s, %08x ('%s'), %08x ('%s'), %02x)\n",
sname.c_str(),
creator, ToolBox::TypeToString(creator).c_str(),
fileType, ToolBox::TypeToString(fileType).c_str(),
scriptTag);
sname = OS::FSSpecManager::ExpandPath(sname, parentID);
if (sname.empty())
{
return SetResError(MacOS::dirNFErr);
}
auto rv = CreateResFile(sname);
// returns errFSForkExists if fork already exists.
// therefore, if no error, set the ftype/ctype.
if (rv.error() == 0)
{
2014-12-26 21:31:03 +00:00
OS::Internal::SetFinderInfo(sname, fileType, creator);
2014-12-22 03:30:04 +00:00
}
return SetResError(rv.error() == errFSForkExists ? 0 : rv.error());
}
2014-12-20 17:20:34 +00:00
tool_return<int16_t> OpenResCommon(const std::string &path, uint16_t permission = 0)
{
OSErr error;
FSRef ref;
ResFileRefNum refNum;
error = ::FSPathMakeRef( (const UInt8 *)path.c_str(), &ref, NULL);
if (error != noErr)
return (MacOS::macos_error)error;
HFSUniStr255 fork = {0,{0}};
::FSGetResourceForkName(&fork);
2014-12-20 17:20:34 +00:00
refNum = -1;
error = ::FSOpenResourceFile(&ref,
fork.length,
fork.unicode,
permission,
&refNum);
2014-12-20 17:20:34 +00:00
if (error != noErr)
2014-12-20 17:20:34 +00:00
return (MacOS::macos_error)error;
return refNum;
}
2013-06-28 01:54:58 +00:00
uint16_t OpenResFile(uint16_t trap)
{
// OpenResFile (fileName: Str255) : INTEGER;
uint32_t sp;
uint32_t fileName;
sp = StackFrame<4>(fileName);
std::string sname = ToolBox::ReadPString(fileName, true);
Log("%04x OpenResFile(%s)\n", trap, sname.c_str());
auto rv = OpenResCommon(sname);
2013-06-28 01:54:58 +00:00
ToolReturn<2>(sp, rv.value_or(-1));
2013-06-28 01:54:58 +00:00
return SetResError(rv.error());
2013-06-28 01:54:58 +00:00
}
2014-12-16 18:07:51 +00:00
uint16_t HOpenResFile(uint16_t trap)
{
// FUNCTION HOpenResFile (vRefNum: Integer; dirID: LongInt;
// fileName: Str255; permission: SignedByte): Integer;
uint32_t sp;
uint16_t vRefNum;
uint32_t dirID;
uint32_t fileName;
2015-01-05 18:13:14 +00:00
uint8_t permission;
2014-12-16 18:07:51 +00:00
sp = StackFrame<12>(vRefNum, dirID, fileName, permission);
std::string sname = ToolBox::ReadPString(fileName, true);
Log("%04x HOpenResFile(%04x, %08x, %s, %04x)\n",
trap, vRefNum, dirID, sname.c_str(), permission);
if (vRefNum) {
fprintf(stderr, "HOpenResFile: vRefNum not supported yet.\n");
exit(1);
}
sname = OS::FSSpecManager::ExpandPath(sname, dirID);
if (sname.empty())
{
ToolReturn<2>(sp, (uint16_t)-1);
return SetResError(MacOS::dirNFErr);
2014-12-16 18:07:51 +00:00
}
auto rv = OpenResCommon(sname, permission);
2014-12-16 18:07:51 +00:00
ToolReturn<2>(sp, rv.value_or(-1));
2014-12-16 18:07:51 +00:00
return SetResError(rv.error());
2014-12-16 18:07:51 +00:00
}
2013-06-28 01:54:58 +00:00
2014-12-20 17:20:34 +00:00
uint16_t FSpOpenResFile(void)
{
// FUNCTION FSpOpenResFile (spec: FSSpec; permission: SignedByte): Integer;
uint32_t sp;
uint32_t spec;
2015-01-05 18:13:14 +00:00
uint8_t permission;
2014-12-20 17:20:34 +00:00
sp = StackFrame<6>(spec, permission);
int parentID = memoryReadLong(spec + 2);
std::string sname = ToolBox::ReadPString(spec + 6, false);
Log(" FSpOpenResFile(%s, %04x)\n", sname.c_str(), permission);
sname = OS::FSSpecManager::ExpandPath(sname, parentID);
if (sname.empty())
{
ToolReturn<2>(sp, (uint16_t)-1);
return SetResError(MacOS::dirNFErr);
}
2014-12-20 17:20:34 +00:00
auto rv = OpenResCommon(sname, permission);
ToolReturn<2>(sp, rv.value_or(-1));
return SetResError(rv.error());
}
2013-03-03 01:53:54 +00:00
2014-12-22 03:30:04 +00:00
2013-06-24 02:05:57 +00:00
uint16_t OpenRFPerm(uint16_t trap)
{
// FUNCTION OpenRFPerm (fileName: Str255; vRefNum: Integer;
// permission: SignedByte): Integer;
ResFileRefNum refNum;
FSRef ref;
uint32_t sp;
uint32_t fileName;
uint16_t vRefNum;
uint16_t permission;
OSErr error;
sp = StackFrame<8>(fileName, vRefNum, permission);
std::string sname = ToolBox::ReadPString(fileName, true);
Log("%04x OpenRFPerm(%s, %04x, %04x)\n",
trap, sname.c_str(), vRefNum, permission);
2013-06-25 02:53:17 +00:00
error = ::FSPathMakeRef( (const UInt8 *)sname.c_str(), &ref, NULL);
2013-06-24 02:05:57 +00:00
if (error != noErr)
{
ToolReturn<2>(sp, (uint16_t)-1);
return SetResError(error);
}
HFSUniStr255 fork = {0,{0}};
2013-06-25 02:53:17 +00:00
::FSGetResourceForkName(&fork);
2013-06-24 02:05:57 +00:00
refNum = -1;
2013-06-25 02:53:17 +00:00
error = ::FSOpenResourceFile(&ref,
2013-06-24 02:05:57 +00:00
fork.length,
fork.unicode,
permission,
&refNum);
ToolReturn<2>(sp, (uint16_t)refNum);
return SetResError(error);
}
2013-06-25 02:53:17 +00:00
uint16_t Count1Resources(uint16_t trap)
{
// FUNCTION Count1Resources (theType: ResType): Integer;
uint32_t sp;
uint32_t theType;
uint16_t count;
sp = StackFrame<4>(theType);
Log("%04x Count1Resources(%08x ('%s'))\n",
trap, theType, TypeToString(theType).c_str());
count = ::Count1Resources(theType);
ToolReturn<2>(sp, count);
return SetResError(0);
}
uint16_t UpdateResFile(uint16_t trap)
{
// PROCEDURE UpdateResFile (refNum: Integer);
uint16_t refNum;
StackFrame<2>(refNum);
Log("%04x UpdateResFile(%04x)\n", trap, refNum);
::UpdateResFile(refNum);
return SetResError(::ResError());
}
uint16_t GetResFileAttrs(uint16_t trap)
{
// FUNCTION GetResFileAttrs (refNum: Integer): Integer;
uint32_t sp;
uint16_t attrs;
uint16_t refNum;
sp = StackFrame<2>(refNum);
Log("%04x GetResFileAttrs(%04x)\n", trap, refNum);
attrs = ::GetResFileAttrs(refNum);
ToolReturn<2>(sp, attrs);
return SetResError(::ResError());
}
uint16_t SetResFileAttrs(uint16_t trap)
{
// PROCEDURE SetResFileAttrs (refNum: Integer; attrs: Integer);
uint32_t sp;
uint16_t attrs;
uint16_t refNum;
sp = StackFrame<4>(refNum, attrs);
Log("%04x GetResFileAttrs(%04x, %04x)\n", trap, refNum, attrs);
::SetResFileAttrs(refNum, attrs);
return SetResError(::ResError());
}
2013-06-27 03:24:20 +00:00
// TODO -- update rhandle_map when loading resources
// TODO -- update rhandle_map when disposing resources.
uint16_t AddResource(uint16_t trap)
{
// PROCEDURE AddResource (theData: Handle; theType: ResType;
// theID: Integer; name: Str255);
uint32_t theData;
uint32_t theType;
uint16_t theID;
uint32_t namePtr;
StackFrame<14>(theData, theType, theID, namePtr);
std::string sname = ToolBox::ReadPString(namePtr, false);
Log("%04x AddResource(%08x, %08x ('%s'), %04x, %s)\n",
2013-08-25 16:44:19 +00:00
trap, theData, theType, TypeToString(theType).c_str(), theID, sname.c_str()
2013-06-27 03:24:20 +00:00
);
Handle nativeHandle = NULL;
if (theData)
{
uint32_t handleSize;
MM::Native::GetHandleSize(theData, handleSize);
if (handleSize)
{
nativeHandle = ::NewHandle(handleSize);
if (!nativeHandle) return SetResError(MacOS::addResFailed);
uint32_t src = memoryReadLong(theData);
std::memcpy(*(uint8_t **)nativeHandle, memoryPointer(src), handleSize);
rhandle_map.insert({theData, nativeHandle});
}
}
// AddResource assumes ownership of the handle.
::AddResource(nativeHandle, theType, theID, memoryPointer(namePtr));
return SetResError(::ResError());
}
uint16_t SetResAttrs(uint16_t trap)
{
// PROCEDURE SetResAttrs (theResource: Handle; attrs: Integer);
uint32_t theResource;
uint16_t attrs;
StackFrame<6>(theResource, attrs);
Log("%04x SetResAttrs(%08x, %04x)\n", trap, theResource, attrs);
// find the native handle..
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end()) return SetResError(MacOS::resNotFound);
Handle nativeHandle = iter->second;
::SetResAttrs(nativeHandle, attrs);
return SetResError(::ResError());
}
2013-06-28 00:27:55 +00:00
uint16_t GetResAttrs(uint16_t trap)
{
// FUNCTION GetResAttrs (theResource: Handle): Integer;
uint32_t sp;
uint32_t theResource;
uint16_t attrs;
sp = StackFrame<4>(theResource);
Log("%04x GetResAttrs(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end())
{
ToolReturn<2>(sp, 0);
return SetResError(MacOS::resNotFound);
}
Handle nativeHandle = iter->second;
attrs = ::GetResAttrs(nativeHandle);
ToolReturn<2>(sp, attrs);
return SetResError(::ResError());
}
2013-06-27 03:24:20 +00:00
uint16_t WriteResource(uint16_t trap)
{
// PROCEDURE WriteResource (theResource: Handle);
2013-06-25 02:53:17 +00:00
2013-06-27 03:24:20 +00:00
uint32_t theResource;
StackFrame<4>(theResource);
Log("%04x WriteResource(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end()) return SetResError(MacOS::resNotFound);
Handle nativeHandle = iter->second;
// todo -- need to verify handle size, re-copy handle memory?
::WriteResource(nativeHandle);
return SetResError(::ResError());
}
uint16_t DetachResource(uint16_t trap)
{
// PROCEDURE DetachResource (theResource: Handle);
uint32_t theResource;
StackFrame<4>(theResource);
Log("%04x DetachResource(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end()) return SetResError(MacOS::resNotFound);
Handle nativeHandle = iter->second;
rhandle_map.erase(iter);
::ReleaseResource(nativeHandle);
return SetResError(::ResError());
}
2013-06-24 02:05:57 +00:00
2013-06-28 00:27:55 +00:00
uint16_t Get1IndResource(uint16_t trap)
{
// FUNCTION Get1IndResource (theType: ResType; index: Integer): Handle;
uint32_t sp;
uint32_t theType;
uint16_t index;
sp = StackFrame<6>(theType, index);
Log("%04x Get1IndResource(%08x ('%s'), %04x)\n",
trap, theType, TypeToString(theType).c_str(), index);
uint32_t resourceHandle = 0;
uint16_t d0;
d0 = Native::LoadResource(theType, resourceHandle,
[theType, index](){
return ::Get1IndResource(theType, index);
}
);
ToolReturn<4>(sp, resourceHandle);
return SetResError(d0);
}
uint16_t RemoveResource(uint16_t trap)
{
// PROCEDURE RemoveResource (theResource: Handle);
uint32_t theResource;
StackFrame<4>(theResource);
Log("%04x RemoveResource(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end()) return SetResError(MacOS::resNotFound);
Handle nativeHandle = iter->second;
rhandle_map.erase(iter);
::RemoveResource(nativeHandle);
::DisposeHandle(nativeHandle);
return SetResError(::ResError());
}
2013-06-30 17:08:26 +00:00
uint16_t GetResourceSizeOnDisk(uint16_t trap)
{
// FUNCTION GetResourceSizeOnDisk (theResource: Handle): LongInt;
uint32_t sp;
uint32_t theResource;
sp = StackFrame<4>(theResource);
Log("%04x GetResourceSizeOnDisk(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end())
{
ToolReturn<4>(sp, (uint32_t)0);
return SetResError(MacOS::resNotFound);
}
Handle nativeHandle = iter->second;
uint32_t size = ::GetResourceSizeOnDisk(nativeHandle);
ToolReturn<4>(sp, size);
return SetResError(::ResError());
}
2013-08-03 23:19:44 +00:00
uint16_t GetResInfo(uint16_t trap)
{
// PROCEDURE GetResInfo (theResource: Handle;
// VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
uint32_t theResource;
uint32_t theID;
uint32_t theType;
uint32_t name;
StackFrame<16>(theResource, theID, theType, name);
Log("%04x GetResInfo(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end())
{
return SetResError(MacOS::resNotFound);
}
Handle nativeHandle = iter->second;
ResID nativeID = 0;
ResType nativeType = 0;
Str255 nativeName = {0};
::GetResInfo(nativeHandle, &nativeID, &nativeType, nativeName);
if (theID) memoryWriteWord(nativeID, theID);
if (theType) memoryWriteLong(nativeType, theType);
if (name)
{
std::string sname(nativeName + 1, nativeName + 1 + nativeName[0]);
ToolBox::WritePString(name, sname);
}
return SetResError(::ResError());
}
uint16_t LoadResource(uint16_t trap)
{
// PROCEDURE LoadResource (theResource: Handle);
// this loads the resource from disk, if not already
// loaded. (if purgeable or SetResLoad(false))
// this needs cooperation with MM to check if
// handle was purged.
OSErr err;
uint32_t theResource;
StackFrame<4>(theResource);
Log("%04x LoadResource(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end())
{
return SetResError(MacOS::resNotFound);
}
// if it has a size, it's loaded...
uint32_t handleSize;
err = MM::Native::GetHandleSize(theResource, handleSize);
if (err) return SetResError(err);
if (handleSize) return SetResError(0);
// otherwise, load it
Handle nativeHandle;
uint32_t size;
nativeHandle = iter->second;
::LoadResource(nativeHandle);
err = ::ResError();
if (err) return SetResError(err); // ?!?!
size = ::GetHandleSize(nativeHandle);
err = MM::Native::ReallocHandle(theResource, size);
if (err) return SetResError(err);
2013-08-16 03:36:26 +00:00
// todo -- need to lock if resource locked.
2013-08-03 23:19:44 +00:00
if (size)
{
uint32_t ptr = memoryReadLong(theResource);
std::memcpy(memoryPointer(ptr), *(void **)nativeHandle, size);
}
return SetResError(0);
}
2013-08-18 04:51:31 +00:00
uint16_t HomeResFile(uint16_t trap)
{
// PPCAsm
// FUNCTION HomeResFile (theResource: Handle): Integer;
uint32_t sp;
uint32_t theResource;
uint16_t resFile;
sp = StackFrame<4>(theResource);
Log("%04x HomeResFile(%08x)\n", trap, theResource);
auto iter = rhandle_map.find(theResource);
if (iter == rhandle_map.end())
{
2014-12-23 13:44:45 +00:00
ToolReturn<2>(sp, -1);
2013-08-18 04:51:31 +00:00
return SetResError(MacOS::resNotFound);
}
resFile = ::HomeResFile(iter->second);
ToolReturn<2>(sp, resFile);
return SetResError(::ResError());
}
2013-08-18 05:10:14 +00:00
uint16_t Count1Types(uint16_t trap)
{
// FUNCTION Count1Types: Integer;
uint16_t count;
Log("%04x Count1Types\n", trap);
count = ::Count1Types();
ToolReturn<2>(-1, count);
return SetResError(::ResError());
}
uint16_t Get1IndType(uint16_t trap)
{
// PROCEDURE Get1IndType (VAR theType: ResType; index: Integer);
uint32_t theType;
uint16_t index;
StackFrame<6>(theType, index);
Log("%04x Get1IndType(%08x, %04x)\n", trap, theType, index);
ResType nativeType = 0;
::Get1IndType(&nativeType, index);
memoryWriteLong(nativeType, theType);
return SetResError(::ResError());
}
2013-02-07 04:44:12 +00:00
}