Macintosh-SW/mpw
1
0
Fork 0
mirror of https://github.com/ksherlock/mpw.git synced 2024-11-22 15:31:50 +00:00
Code Issues Projects Releases Wiki Activity

update Native tool calls to use tool_return<> for return values.

Browse Source
This commit is contained in:
Kelvin Sherlock 2016-08-01 13:56:43 -04:00
parent 45e7e81169
commit 94f4c1c528
9 changed files with 293 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
mpw/mpw.cpp
View File

@ -263,8 +263,6 @@ namespace MPW
uint32_t devptr = 0;
uint32_t fptr = 0;
uint16_t error;
// create the argv-data.
{
uint32_t size = 0;
@ -278,8 +276,9 @@ namespace MPW
size += l;
}
error = MM::Native::NewPtr(size, true, argvptr);
if (error) return error;
auto tmp = MM::Native::NewPtr(size, true);
if (tmp.error()) return tmp.error();
argvptr = tmp.value();
uint8_t *xptr = memoryPointer(argvptr);
@ -331,9 +330,9 @@ namespace MPW
size += 4; // space for null terminator.
error = MM::Native::NewPtr(size, true, envptr);
if (error) return error;
auto tmp = MM::Native::NewPtr(size, true);
if (tmp.error()) return tmp.error();
envptr = tmp.value();
uint8_t *xptr = memoryPointer(envptr);
uint32_t offset = 0;
@ -364,9 +363,9 @@ namespace MPW
// these are ftraps for emulated/native function ptrs.
uint32_t size = 6 * 4;
error = MM::Native::NewPtr(size, true, fptr);
if (error) return error;
auto tmp = MM::Native::NewPtr(size, true);
if (tmp.error()) return tmp.error();
fptr = tmp.value();
memoryWriteWord(fQuit, fptr + 0);
memoryWriteWord(0x4E75, fptr + 2); // rts
@ -393,9 +392,9 @@ namespace MPW
{
uint32_t size = 0x78;
error = MM::Native::NewPtr(size, true, devptr);
if (error) return error;
auto tmp = MM::Native::NewPtr(size, true);
if (tmp.error()) return tmp.error();
devptr = tmp.value();
memoryWriteLong(0x46535953, devptr + 0); // 'FSYS'
memoryWriteLong(fptr + 4, devptr + 4);
@ -415,9 +414,9 @@ namespace MPW
uint32_t size = 0x3c;
uint32_t ptr;
error = MM::Native::NewPtr(size, true, ioptr);
if (error) return error;
auto tmp = MM::Native::NewPtr(size, true);
if (tmp.error()) return tmp.error();
ioptr = tmp.value();
ptr = ioptr;
// stdin
@ -450,10 +449,9 @@ namespace MPW
uint32_t mpi = 0;
error = MM::Native::NewPtr(8 + 0x30, true, mpi);
if (error) return error;
auto tmp = MM::Native::NewPtr(8 + 0x30, true);
if (tmp.error()) return tmp.error();
uint32_t mpi = tmp.value();
MacProgramInfo = mpi + 8;

3
toolbox/dispatch.cpp
View File

@ -350,7 +350,8 @@ namespace ToolBox {
// alternate entry code
MM::Native::NewPtr(1024 * 4 + 256 * 4, false, ToolGlue);
auto tmp = MM::Native::NewPtr(1024 * 4 + 256 * 4, false);
ToolGlue = tmp.value();
OSGlue = ToolGlue + 1024 * 4;
uint16_t *code = (uint16_t *)memoryPointer(ToolGlue);

73
toolbox/loader.cpp
View File

@ -148,21 +148,24 @@ namespace Loader {
// load code seg 0.
uint16_t LoadCode0(Segment0Info &rv)
{
uint16_t err;
uint32_t rHandle;
uint32_t size;
uint32_t address;
SegmentInfo si;
err = RM::Native::GetResource(kCODE, 0, rHandle);
if (err) return err;
{
auto tmp = RM::Native::GetResource(kCODE, 0);
if (tmp.error()) return tmp.error();
rHandle = tmp.value();
}
MM::Native::HLock(rHandle);
MM::Native::GetHandleSize(rHandle, size);
address = memoryReadLong(rHandle);
{
auto tmp = MM::Native::GetHandleInfo(rHandle);
address = tmp.value().address;
size = tmp.value().size;
}
uint32_t above = memoryReadLong(address);
uint32_t below = memoryReadLong(address + 4);
@ -173,8 +176,12 @@ namespace Loader {
// create a new handle for the a5 segment.
err = MM::Native::NewHandle(si.size, true, si.handle, si.address);
if (err) return err;
{
auto tmp = MM::Native::NewHandle(si.size, true);
if (tmp.error()) return tmp.error();
si.handle = tmp.value().handle;
si.address = tmp.value().pointer;
}
MM::Native::HLock(si.handle);
@ -198,17 +205,21 @@ namespace Loader {
// load a standard code segment.
uint16_t LoadCode(uint16_t segment)
{
uint16_t err;
SegmentInfo si;
err = RM::Native::GetResource(kCODE, segment, si.handle);
if (err) return err;
{
auto tmp = RM::Native::GetResource(kCODE, segment);
if (tmp.error()) return tmp.error();
si.handle = tmp.value();
}
MM::Native::HLock(si.handle);
MM::Native::GetHandleSize(si.handle, si.size);
si.address = memoryReadLong(si.handle);
{
auto tmp = MM::Native::GetHandleInfo(si.handle);
si.size = tmp.value().size;
si.address = tmp.value().address;
}
if (memoryReadWord(si.address) == 0xffff)
si.farModel = true;
@ -343,7 +354,7 @@ namespace Loader {
{
std::string s;
auto ix = path.rfind('/');
auto ix = path.find_last_of("/:", 0, 2);
if (ix == path.npos)
{
s = path.substr(0, 31);
@ -552,5 +563,35 @@ namespace Loader {
}
uint16_t LoadSeg(uint16_t trap) {
/*
* Jump Table Entry:
*
* Unloaded:
* +0 offset
* +2 instruction that pushes segment number onto stack
* +6 LoadSeg trap
*
* Loaded:
* +0 offset
* +2 jump instruction.
*
*/
uint32_t sp;
uint16_t segment;
sp = StackFrame<2>(segment);
Log("%04x LoadSeg(%04x)\n", trap, segment);
return 0;
}
}

1
toolbox/loader.h
View File

@ -26,6 +26,7 @@ namespace Loader {
}
uint16_t LoadSeg(uint16_t trap);
uint16_t UnloadSeg(uint16_t trap);
}

265
toolbox/mm.cpp
View File

@ -45,6 +45,9 @@
using ToolBox::Log;
using MacOS::tool_return;
using MacOS::macos_error_from_errno;
using MacOS::macos_error;
namespace
{
@ -65,15 +68,15 @@ namespace
// map of handle -> size [? just use Ptr map?]
std::map<uint32_t, MM::HandleInfo> HandleMap;
inline MacOS::macos_error SetMemError(MacOS::macos_error error)
inline macos_error SetMemError(macos_error error)
{
memoryWriteWord(error, MacOS::MemErr);
return error;
}
inline MacOS::macos_error SetMemError(int16_t error)
inline macos_error SetMemError(int16_t error)
{
return SetMemError((MacOS::macos_error)error);
return SetMemError((macos_error)error);
}
@ -98,13 +101,6 @@ namespace
}
template<class Fx>
int16_t with_handle(uint32_t handle, Fx fx)
{
auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return MacOS::memWZErr;
return fx(iter->second);
}
}
namespace MM
@ -139,6 +135,46 @@ namespace MM
namespace Native {
template<class T>
struct tool_return_base { typedef T type; };
template<class T>
struct tool_return_base<tool_return<T>> { typedef T type; };
template<class T, class F>
tool_return<T> with_handle_helper(F &&f, HandleInfo &info, typename std::enable_if<!std::is_void<T>::value>::type* = 0) {
tool_return<T> rv = f(info);
return rv;
}
template<class T, class F>
tool_return<void> with_handle_helper(F &&f, HandleInfo &info, typename std::enable_if<std::is_void<T>::value>::type* = 0) {
f(info);
return tool_return<void>();
}
template<class F, typename T = typename tool_return_base<typename std::result_of<F(HandleInfo &)>::type>::type>
tool_return<T>
__with_handle(uint32_t handle, F &&f)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) {
tool_return<T> rv = SetMemError(MacOS::memWZErr);
return rv;
}
auto &info = iter->second;
//tool_return<T> rv = f(info);
tool_return<T> rv = with_handle_helper<T>(std::forward<F>(f), info);
SetMemError(rv.error());
return rv;
}
// debugger support.
// print info on an address.
void MemoryInfo(uint32_t address)
@ -233,11 +269,11 @@ namespace MM
}
uint16_t NewPtr(uint32_t size, bool clear, uint32_t &mcptr)
tool_return<uint32_t> NewPtr(uint32_t size, bool clear)
{
// native pointers.
mcptr = 0;
uint32_t mcptr = 0;
//if (size == 0) return 0;
uint8_t *ptr = nullptr;
@ -253,10 +289,11 @@ namespace MM
mcptr = ptr - Memory;
PtrMap.emplace(std::make_pair(mcptr, size));
return SetMemError(0);
SetMemError(0);
return mcptr;
}
uint16_t DisposePtr(uint32_t mcptr)
tool_return<void> DisposePtr(uint32_t mcptr)
{
auto iter = PtrMap.find(mcptr);
@ -271,13 +308,13 @@ namespace MM
return SetMemError(0);
}
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle, uint32_t &mcptr)
tool_return<hp> NewHandle(uint32_t size, bool clear)
{
uint8_t *ptr;
uint32_t hh;
handle = 0;
mcptr = 0;
uint32_t handle = 0;
uint32_t mcptr = 0;
if (!HandleQueue.size())
{
@ -316,18 +353,12 @@ namespace MM
memoryWriteLong(mcptr, hh);
handle = hh;
return SetMemError(0);
}
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle)
{
uint32_t ptr;
return NewHandle(size, clear, handle, ptr);
SetMemError(0);
return hp{handle, mcptr};
}
uint16_t DisposeHandle(uint32_t handle)
tool_return<void> DisposeHandle(uint32_t handle)
{
auto iter = HandleMap.find(handle);
@ -349,19 +380,9 @@ namespace MM
}
uint16_t GetHandleSize(uint32_t handle, uint32_t &handleSize)
{
handleSize = 0;
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
handleSize = iter->second.size;
return SetMemError(0);
}
uint16_t ReallocHandle(uint32_t handle, uint32_t logicalSize)
tool_return<void> ReallocHandle(uint32_t handle, uint32_t logicalSize)
{
auto iter = HandleMap.find(handle);
@ -400,12 +421,12 @@ namespace MM
// lock? clear purged flag?
return 0;
return MacOS::noErr;
}
uint16_t SetHandleSize(uint32_t handle, uint32_t newSize)
tool_return<void> SetHandleSize(uint32_t handle, uint32_t newSize)
{
if (handle == 0) return SetMemError(MacOS::nilHandleErr);
@ -519,61 +540,35 @@ namespace MM
}
// template class to validate handle and work on it.
template<class FX>
uint16_t HandleIt(uint32_t handle, FX fx)
tool_return<void> HSetRBit(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
auto &info = iter->second;
fx(info);
return SetMemError(0);
return __with_handle(handle, [](HandleInfo &info) { info.resource = true; });
}
uint16_t HSetRBit(uint32_t handle)
tool_return<void> HClrRBit(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
auto &info = iter->second;
info.resource = true;
return SetMemError(0);
return __with_handle(handle, [](HandleInfo &info) { info.resource = false; });
}
uint16_t HClrRBit(uint32_t handle)
tool_return<void> HLock(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
auto &info = iter->second;
info.resource = false;
return SetMemError(0);
return __with_handle(handle, [](HandleInfo &info) { info.locked = true; });
}
uint16_t HLock(uint32_t handle)
tool_return<void> HUnlock(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
auto &info = iter->second;
info.locked = true;
return SetMemError(0);
return __with_handle(handle, [](HandleInfo &info) { info.locked = false; });
}
uint16_t HUnlock(uint32_t handle)
tool_return<uint32_t> GetHandleSize(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
return __with_handle(handle, [](const HandleInfo &info){ return info.size; });
}
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
auto &info = iter->second;
info.locked = false;
return SetMemError(0);
tool_return<HandleInfo> GetHandleInfo(uint32_t handle)
{
return __with_handle(handle, [](const HandleInfo &info){ return info; });
}
@ -583,25 +578,7 @@ namespace MM
#pragma mark --
tool_return<uint32_t> GetHandleSize(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
SetMemError(0);
return iter->second.size;
}
tool_return<HandleInfo> GetHandleInfo(uint32_t handle)
{
const auto iter = HandleMap.find(handle);
if (iter == HandleMap.end()) return SetMemError(MacOS::memWZErr);
SetMemError(0);
return iter->second;
}
#pragma mark --
@ -828,12 +805,10 @@ namespace MM
// todo -- separate pools for sys vs non-sys?
// todo -- NewPtr(0) -- null or empty ptr?
uint32_t mcptr;
uint16_t error;
error = Native::NewPtr(size, clear, mcptr);
auto rv = Native::NewPtr(size, clear);
cpuSetAReg(0, mcptr);
return error; //SetMemError(error);
cpuSetAReg(0, rv.value());
return rv.error(); //SetMemError(error);
}
uint16_t DisposePtr(uint16_t trap)
@ -852,10 +827,9 @@ namespace MM
Log("%04x DisposePtr(%08x)\n", trap, mcptr);
uint16_t error;
error = Native::DisposePtr(mcptr);
auto rv = Native::DisposePtr(mcptr);
return error; //SetMemError(error);
return rv.error(); //SetMemError(error);
}
uint32_t GetPtrSize(uint16_t trap)
@ -928,8 +902,6 @@ namespace MM
*
*/
uint32_t hh = 0;
uint16_t error;
bool clear = trap & (1 << 9);
//bool sys = trap & (1 << 10);
@ -938,10 +910,10 @@ namespace MM
Log("%04x NewHandle(%08x)\n", trap, size);
error = Native::NewHandle(size, clear, hh);
auto rv = Native::NewHandle(size, clear);
cpuSetAReg(0, hh);
return error;
cpuSetAReg(0, rv.value().handle);
return rv.error();
}
uint16_t DisposeHandle(uint16_t trap)
@ -959,7 +931,7 @@ namespace MM
Log("%04x DisposeHandle(%08x)\n", trap, hh);
return Native::DisposeHandle(hh);
return Native::DisposeHandle(hh).error();
}
uint16_t EmptyHandle(uint16_t trap)
@ -1026,7 +998,7 @@ namespace MM
Log("%04x ReallocHandle(%08x, %08x)\n", trap, hh, logicalSize);
return Native::ReallocHandle(hh, logicalSize);
return Native::ReallocHandle(hh, logicalSize).error();
#if 0
auto iter = HandleMap.find(hh);
@ -1121,7 +1093,7 @@ namespace MM
Log("%04x SetHandleSize(%08x, %08x)\n", trap, hh, newSize);
return Native::SetHandleSize(hh, newSize);
return Native::SetHandleSize(hh, newSize).error();
}
uint32_t RecoverHandle(uint16_t trap)
@ -1368,16 +1340,15 @@ namespace MM
auto const info = iter->second;
uint32_t destHandle;
uint32_t destPtr;
uint32_t d0 = Native::NewHandle(info.size, false, destHandle, destPtr);
if (d0 == 0)
auto rv = Native::NewHandle(info.size, false);
if (!rv.error())
{
std::memmove(memoryPointer(destPtr), memoryPointer(info.address), info.size);
std::memmove(memoryPointer(rv.value().pointer), memoryPointer(info.address), info.size);
}
cpuSetAReg(0, destHandle);
return d0; // SetMemError called by Native::NewHandle.
cpuSetAReg(0, rv.value().handle);
return rv.error(); // SetMemError called by Native::NewHandle.
}
@ -1399,16 +1370,14 @@ namespace MM
Log("%04x PtrToHand(%08x, %08x)\n", trap, mcptr, size);
uint32_t destHandle;
uint32_t destPtr;
uint32_t d0 = Native::NewHandle(size, false, destHandle, destPtr);
if (d0 == 0)
auto rv = Native::NewHandle(size, false);
if (!rv.error())
{
std::memmove(memoryPointer(destPtr), memoryPointer(mcptr), size);
std::memmove(memoryPointer(rv.value().pointer), memoryPointer(mcptr), size);
}
cpuSetAReg(0, destHandle);
return d0; // SetMemError called by Native::NewHandle.
cpuSetAReg(0, rv.value().handle);
return rv.error(); // SetMemError called by Native::NewHandle.
}
uint16_t PtrAndHand(uint16_t trap)
@ -1435,18 +1404,16 @@ namespace MM
cpuSetAReg(0, handle);
uint32_t oldSize = 0;
uint32_t d0;
d0 = Native::GetHandleSize(handle, oldSize);
if (d0) return d0;
auto tmp = Native::GetHandleSize(handle);
if (tmp.error()) return tmp.error();
uint32_t oldSize = tmp.value();
if ((uint64_t)oldSize + (uint64_t)size > UINT32_MAX)
return SetMemError(MacOS::memFullErr);
d0 = Native::SetHandleSize(handle, oldSize + size);
if (d0) return d0;
auto err = Native::SetHandleSize(handle, oldSize + size);
if (err.error()) return err.error();
auto iter = HandleMap.find(handle);
if (iter == HandleMap.end())
@ -1637,20 +1604,18 @@ namespace MM
{
// FUNCTION TempNewHandle (logicalSize: Size;
// VAR resultCode: OSErr): Handle;
uint16_t rv;
uint32_t logicalSize;
uint32_t resultCode;
uint32_t theHandle;
uint32_t sp = StackFrame<8>(logicalSize, resultCode);
Log(" TempNewHandle(%08x, %08x)\n", logicalSize, resultCode);
rv = Native::NewHandle(logicalSize, true, theHandle);
auto rv = Native::NewHandle(logicalSize, true);
if (resultCode) memoryWriteWord(rv, resultCode);
ToolReturn<4>(sp, theHandle);
return rv;
if (resultCode) memoryWriteWord(rv.error(), resultCode);
ToolReturn<4>(sp, rv.value().handle);
return rv.error();
}
uint16_t TempHLock(void)
@ -1663,10 +1628,10 @@ namespace MM
Log(" TempHLock(%08x, %08x)\n", theHandle, resultCode);
uint16_t rv = Native::HLock(theHandle);
auto rv = Native::HLock(theHandle);
if (resultCode) memoryWriteWord(rv, resultCode);
return rv;
if (resultCode) memoryWriteWord(rv.error(), resultCode);
return rv.error();
}
uint16_t TempHUnlock(void)
@ -1679,10 +1644,10 @@ namespace MM
Log(" TempHUnlock(%08x, %08x)\n", theHandle, resultCode);
uint16_t rv = Native::HUnlock(theHandle);
auto rv = Native::HUnlock(theHandle);
if (resultCode) memoryWriteWord(rv, resultCode);
return rv;
if (resultCode) memoryWriteWord(rv.error(), resultCode);
return rv.error();
}
@ -1696,9 +1661,9 @@ namespace MM
Log(" TempDisposeHandle(%08x, %08x)\n", theHandle, resultCode);
uint16_t rv = Native::DisposeHandle(theHandle);
auto rv = Native::DisposeHandle(theHandle);
if (resultCode) memoryWriteWord(rv, resultCode);
return rv;
if (resultCode) memoryWriteWord(rv.error(), resultCode);
return rv.error();
}
}

77
toolbox/mm.h
View File

@ -5,37 +5,9 @@
#include <macos/tool_return.h>
namespace MM
{
// native functions.
namespace Native
{
void MemoryInfo(uint32_t address);
void PrintMemoryStats();
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle);
uint16_t NewHandle(uint32_t size, bool clear, uint32_t &handle, uint32_t &ptr);
uint16_t NewPtr(uint32_t size, bool clear, uint32_t &pointer);
uint16_t DisposeHandle(uint32_t handle);
uint16_t DisposePtr(uint32_t pointer);
uint16_t GetHandleSize(uint32_t handle, uint32_t &handleSize);
uint16_t SetHandleSize(uint32_t handle, uint32_t newSize);
uint16_t ReallocHandle(uint32_t handle, uint32_t newSize);
uint16_t HSetRBit(uint32_t handle);
uint16_t HClrRBit(uint32_t handle);
uint16_t HLock(uint32_t handle);
uint16_t HUnlock(uint32_t handle);
}
bool Init(uint8_t *memory, uint32_t memorySize, uint32_t globals, uint32_t stack);
struct HandleInfo
{
@ -50,11 +22,54 @@ namespace MM
{}
};
// native functions.
namespace Native
{
using MacOS::tool_return;
struct hp {
uint32_t handle = 0;
uint32_t pointer = 0;
hp() = default;
hp(uint32_t a, uint32_t b) : handle(a), pointer(b) {};
};
void MemoryInfo(uint32_t address);
void PrintMemoryStats();
tool_return<hp> NewHandle(uint32_t size, bool clear);
tool_return<uint32_t> NewPtr(uint32_t size, bool clear);
tool_return<void> DisposeHandle(uint32_t handle);
tool_return<void> DisposePtr(uint32_t pointer);
tool_return<uint32_t> GetHandleSize(uint32_t handle);
tool_return<void> SetHandleSize(uint32_t handle, uint32_t newSize);
tool_return<void> ReallocHandle(uint32_t handle, uint32_t newSize);
tool_return<void> HSetRBit(uint32_t handle);
tool_return<void> HClrRBit(uint32_t handle);
tool_return<void> HLock(uint32_t handle);
tool_return<void> HUnlock(uint32_t handle);
tool_return<HandleInfo> GetHandleInfo(uint32_t handle);
tool_return<uint32_t> GetHandleSize(uint32_t handle);
}
bool Init(uint8_t *memory, uint32_t memorySize, uint32_t globals, uint32_t stack);
using MacOS::tool_return;
tool_return<HandleInfo> GetHandleInfo(uint32_t handle);
tool_return<uint32_t> GetHandleSize(uint32_t handle);
uint16_t BlockMove(uint16_t trap);

58
toolbox/rm.cpp
View File

@ -112,10 +112,10 @@ namespace
std::map<uint32_t, Handle> rhandle_map;
inline uint16_t SetResError(uint16_t error)
inline macos_error SetResError(uint16_t error)
{
memoryWriteWord(error, MacOS::ResErr);
return error;
return (macos_error)error;
}
bool LoadResType(uint32_t type)
@ -165,10 +165,9 @@ namespace RM
// not to be confused with MacOS LoadResource(theHandle)
template<class FX>
uint16_t LoadResource(uint32_t type, uint32_t &theHandle, FX fx)
macos_error LoadResource(uint32_t type, uint32_t &theHandle, FX fx)
{
uint32_t ptr;
uint16_t error;
Handle nativeHandle;
uint32_t size;
@ -190,14 +189,18 @@ namespace RM
if (ResLoad) ::LoadResource(nativeHandle);
size = ::GetHandleSize(nativeHandle);
error = MM::Native::NewHandle(size, false, theHandle, ptr);
{
auto tmp = MM::Native::NewHandle(size, false);
if (tmp.error()) {
::ReleaseResource(nativeHandle);
return SetResError(tmp.error());
}
theHandle = tmp.value().handle;
ptr = tmp.value().pointer;
}
// TODO -- need to lock if native handle locked.
if (!theHandle)
{
::ReleaseResource(nativeHandle);
return SetResError(error);
}
MM::Native::HSetRBit(theHandle);
if (size)
@ -213,15 +216,19 @@ namespace RM
// used by GetString (utility.h)
// used by Loader.
uint16_t GetResource(uint32_t type, uint16_t id, uint32_t &theHandle)
tool_return<uint32_t> GetResource(uint32_t type, uint16_t id)
{
return LoadResource(type, theHandle,
uint32_t theHandle;
auto err = LoadResource(type, theHandle,
[type, id](){
return ::GetResource(type, id);
});
if (!err) return theHandle;
return err;
}
uint16_t SetResLoad(bool load)
tool_return<void> SetResLoad(bool load)
{
ResLoad = load;
@ -232,6 +239,19 @@ namespace RM
}
tool_return<void> CloseResFile(uint16_t refNum)
{
// If the value of the refNum parameter is 0, it represents the System file and is ignored.
if (refNum != 0)
{
::CloseResFile(refNum);
return SetResError(::ResError());
}
return SetResError(0);
}
}
uint16_t CloseResFile(uint16_t trap)
@ -844,7 +864,7 @@ namespace RM
// check if handle size changed, resync data
auto info = MM::GetHandleInfo(theResource);
auto info = MM::Native::GetHandleInfo(theResource);
if (!info.error()) return SetResError(info.error());
@ -928,7 +948,7 @@ namespace RM
Handle nativeHandle = NULL;
auto info = MM::GetHandleInfo(theData);
auto info = MM::Native::GetHandleInfo(theData);
if (info.error()) return SetResError(MacOS::addResFailed);
@ -1179,7 +1199,7 @@ namespace RM
// if it has a size, it's loaded...
auto info = MM::GetHandleInfo(theResource);
auto info = MM::Native::GetHandleInfo(theResource);
if (info.error()) return SetResError(resNotFound);
if (info->size) return SetResError(0);
@ -1198,14 +1218,14 @@ namespace RM
size = ::GetHandleSize(nativeHandle);
err = MM::Native::ReallocHandle(theResource, size);
if (err) return SetResError(err);
auto tmp = MM::Native::ReallocHandle(theResource, size);
if (tmp.error()) return SetResError(tmp.error());
// todo -- need to lock if resource locked.
if (size)
{
info = MM::GetHandleInfo(theResource);
info = MM::Native::GetHandleInfo(theResource);
std::memcpy(memoryPointer(info->address), *(void **)nativeHandle, size);
}

10
toolbox/rm.h
View File

@ -3,13 +3,19 @@
#include <cstdint>
#include <macos/tool_return.h>
namespace RM
{
namespace Native
{
uint16_t SetResLoad(bool tf);
uint16_t GetResource(uint32_t type, uint16_t id, uint32_t &theHandle);
using MacOS::tool_return;
tool_return<void> SetResLoad(bool tf);
tool_return<uint32_t> GetResource(uint32_t type, uint16_t id);
tool_return<void> OpenResFile(const std::string &path_name, uint16_t permissions = 0);
tool_return<void> CloseResFile(uint16_t refNum);
}
uint16_t CloseResFile(uint16_t trap);

25
toolbox/utility.cpp
View File

@ -49,10 +49,8 @@ namespace Utility {
*/
uint32_t theString;
uint32_t theHandle;
uint32_t sp;
uint32_t length = 0;
uint32_t d0;
std::string s;
@ -64,19 +62,12 @@ namespace Utility {
length = s.length() + 1;
// if (length) // always true...
{
uint32_t ptr;
d0 = MM::Native::NewHandle(s.length(), false, theHandle, ptr);
if (!d0)
{
ToolBox::WritePString(ptr, s);
}
}
auto rv = MM::Native::NewHandle(s.length(), false);
if (!rv.error()) ToolBox::WritePString(rv.value().pointer, s);
ToolReturn<4>(sp, theHandle);
return d0;
ToolReturn<4>(sp, rv.value().handle);
return rv.error();
}
// FUNCTION GetString (stringID: Integer): StringHandle;
@ -91,17 +82,15 @@ namespace Utility {
uint16_t stringID;
uint32_t sp;
uint32_t d0;
uint32_t theHandle;
sp = StackFrame<2>(stringID);
Log("%04x GetString($%04x)\n", trap, stringID);
d0 = RM::Native::GetResource(0x53545220, stringID, theHandle);
auto rv = RM::Native::GetResource(0x53545220, stringID);
ToolReturn<4>(sp, theHandle);
return d0;
ToolReturn<4>(sp, rv.value());
return rv.error();
}
// FUNCTION BitTst (bytePtr: Ptr; bitNum: LONGINT) : BOOLEAN;