Macintosh-Tools
/
executor
mirror of https://github.com/ctm/executor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
executor/src/mman.c

2179 lines
44 KiB
C
Raw Permalink Blame History

/* Copyright 1990 - 1996 by Abacus Research and
* Development, Inc. All rights reserved.
*/
#if !defined (OMIT_RCSID_STRINGS)
char ROMlib_rcsid_mman[] =
"$Id: mman.c 88 2005-05-25 03:59:37Z ctm $";
#endif
/* Implementation of MAC memory manager routines */
/* Forward declarations in MemoryMgr.h (DO NOT DELETE THIS LINE) */
#include "rsys/common.h"
#include "MemoryMgr.h"
#include "SegmentLdr.h"
#include "QuickDraw.h"
#include "SysErr.h"
#include "TextEdit.h"
#include "OSEvent.h"
#include "rsys/mman_private.h"
#include "rsys/file.h"
#include "rsys/smash.h"
#include "rsys/memory_layout.h"
#include "rsys/hook.h"
#include "rsys/memsize.h"
#include "rsys/executor.h"
#include "rsys/options.h"
#include "rsys/toolutil.h"
#include "rsys/gestalt.h"
#if defined (MSDOS)
#include "dpmilock.h"
#endif
#if defined (LINUX) || defined (MACOSX)
#include <sys/mman.h>
#if !defined (MAP_ANONYMOUS)
# define MAP_ANONYMOUS MAP_ANON
#endif
#endif /* LINUX */
#if defined(NEXT) && !defined (STRICT_OPENSTEP)
#include <mach/mach_error.h>
#endif
int ROMlib_applzone_size = DEFAULT_APPLZONE_SIZE;
int ROMlib_syszone_size = DEFAULT_SYSZONE_SIZE;
int ROMlib_stack_size = DEFAULT_STACK_SIZE;
/* these two variables define, in ROMlib space, the beginning of mac-memory
and the end of mac memory. They're purpose is to try to prevent routines
like DisposHandle () from crashing when passed a bogus pointer.
Specifically, I know an application that picks up 4 bytes from low-memory
global 0x100 and then calls DisposHandle () on it. That location contains
0xFFFF0048 both here and on a Mac. On a Mac, this doesn't cause a crash.
*/
PUBLIC unsigned long ROMlib_syszone;
PUBLIC unsigned long ROMlib_memtop;
#if defined (MM_MANY_APPLZONES)
/* for debugging, we can have multiple applzones which are used
roundrobin */
int mm_n_applzones = 1;
static int mm_current_applzone;
#endif
/* for routines that simply set MemErr */
#define SET_MEM_ERR(err) \
do { \
GEN_MEM_ERR (err); \
MemErr = CWV (err); \
} while (FALSE)
SignedByte
hlock_return_orig_state (Handle h)
{
block_header_t *block;
SignedByte state;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return 0;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return 0;
}
state = HANDLE_STATE (h, block);
SET_HANDLE_STATE (h, block, state | LOCKBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
return state;
}
Size
zone_size (THz zone)
{
return (char *) ZONE_BK_LIM (zone) - (char *) zone;
}
SignedByte
HGetState (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
/* there used to be a spewy check here that returned noErr (zero
state) if the incoming handle address was `spewy' (less than
0x2000 or between the end of the applzone and the current stack
frame. it got axed */
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return nilHandleErr;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return memWZErr;
}
SET_MEM_ERR (noErr);
return HANDLE_STATE (h, block);
}
void
HSetState (Handle h, SignedByte flags)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, flags);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HLock (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) | LOCKBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HUnlock (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) & ~LOCKBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HPurge (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) | PURGEBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HNoPurge (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) & ~PURGEBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HSetRBit (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) | RSRCBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
void
HClrRBit (Handle h)
{
block_header_t *block;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
SET_HANDLE_STATE (h, block, HANDLE_STATE (h, block) & ~RSRCBIT);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
/* Zone sizes will be zero modulo this number (which must be a power of 2). */
#define ZONE_ALIGN_SIZE 8192
static void
pin_and_align (int *vp, int min, int max)
{
int v = *vp;
v = (v + ZONE_ALIGN_SIZE - 1) & ~(ZONE_ALIGN_SIZE - 1);
if (v < min)
v = min;
else if (v > max)
v = max;
*vp = v;
}
static void
canonicalize_memory_sizes (void)
{
pin_and_align (&ROMlib_applzone_size, MIN_APPLZONE_SIZE, MAX_APPLZONE_SIZE);
pin_and_align (&ROMlib_syszone_size, MIN_SYSZONE_SIZE, MAX_SYSZONE_SIZE);
pin_and_align (&ROMlib_stack_size, MIN_STACK_SIZE, MAX_STACK_SIZE);
}
void
InitApplZone (void)
{
/* ApplZone must already be set before getting here */
/* nisus writer demands that `ApplLimit - ZONE_BK_LIM (ApplZone)' be
greater than (or equal to?) 16384 */
#define APPLZONE_SLOP 16384
canonicalize_memory_sizes ();
#define INIT_APPLZONE_SIZE \
(ROMlib_applzone_size + APPLZONE_SLOP)
HeapEnd = (Ptr) RM ((char *) MR (ApplZone)
+ INIT_APPLZONE_SIZE
- (MIN_BLOCK_SIZE + APPLZONE_SLOP));
InitZone (0, 64, (Ptr) HEAPEND, (Zone *) MR (ApplZone));
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
#define MANDELSLOP (32L * 1024)
void
print_mem_full_message (void)
{
fprintf (stderr,
"Executor has run out of memory. Try specifying "
"a smaller -memory size.\n");
#if defined (MSDOS)
fprintf (stderr,
"Under Windows and Warp, try increasing the DPMI memory "
"available to Executor.\n");
#endif
}
void
ROMlib_InitZones (offset_enum which)
{
static boolean_t beenhere = FALSE;
static Ptr stack_begin, stack_end;
static unsigned long applzone_memory_segment_size;
int init_syszone_size;
#if ERROR_SUPPORTED_P (ERROR_MEMORY_MANAGER_SLAM)
/* Temporarily turn off heap slamming while the heap is being set up. */
boolean_t old_debug_enabled_p;
old_debug_enabled_p = error_set_enabled (ERROR_MEMORY_MANAGER_SLAM, FALSE);
#endif
#define INIT_SYSZONE_SIZE \
(ROMlib_syszone_size)
if (!beenhere)
{
char *memory;
unsigned long total_allocated_memory, total_mac_visible_memory;
Ptr mem_top;
canonicalize_memory_sizes ();
#define STACK_SIZE ROMlib_stack_size
#if defined (MM_MANY_APPLZONES)
applzone_memory_segment_size = (mm_n_applzones * INIT_APPLZONE_SIZE);
#else /* !MM_MANY_APPLZONES */
applzone_memory_segment_size = INIT_APPLZONE_SIZE;
#endif /* !MM_MANY_APPLZONES */
/* Determine total allocated memory. Round up to next 8K
* since that's the page size we pretend to have.
*/
total_mac_visible_memory = (INIT_SYSZONE_SIZE
+ INIT_APPLZONE_SIZE
+ STACK_SIZE);
total_mac_visible_memory = (total_mac_visible_memory + 8191) & ~8191;
total_allocated_memory = (INIT_SYSZONE_SIZE
+ applzone_memory_segment_size
+ STACK_SIZE);
total_allocated_memory = (total_allocated_memory + 8191) & ~8191;
/* Note the memory in gestalt, rounded down the next 8K page multiple. */
gestalt_set_memory_size (total_mac_visible_memory);
/* Allocate memory for SysZone, ApplZone, and stack, contiguously. */
memory = NULL;
#if defined (TRY_TO_MMAP_ZONES)
/* Try to mmap if either malloc failed or bits are set in the high
* byte of any address in the space just allocated.
*/
if (memory == NULL)
memory = mmap_permanent_memory (total_allocated_memory);
#endif /* TRY_TO_MMAP_ZONES */
#if defined (SBRK_PERMANENT_MEMORY)
if (memory == NULL)
{
memory = sbrk (total_allocated_memory);
if (memory == (char *) -1)
memory = NULL;
}
#endif /* SBRK_PERMANENT_MEMORY) */
/* Allocate with malloc if we don't have it yet. */
if (memory == NULL)
memory = malloc (total_allocated_memory);
if (memory == NULL)
{
print_mem_full_message ();
exit (-1);
}
/* can't assign to low-memory globals yet */
mem_top = (Ptr) RM (memory + total_allocated_memory);
stack_begin = ((Ptr) memory
+ INIT_SYSZONE_SIZE
+ applzone_memory_segment_size);
stack_end = stack_begin + STACK_SIZE;
init_syszone_size = INIT_SYSZONE_SIZE;
switch (which)
{
case offset_none:
ROMlib_offset = 0;
break;
case offset_8k:
ROMlib_offset = 8192;
break;
case offset_big:
ROMlib_offset = (uint32) memory;
{
int low_global_room = (char *) &lastlowglobal -
(char *) &nilhandle_H;
#if defined (MSDOS)
dpmi_lock_memory (&nilhandle_H, low_global_room);
#endif
memory += low_global_room;
init_syszone_size -= low_global_room;
}
break;
default:
/* shouldn't get here */
break;
}
MemTop = mem_top;
SysZone = (void *) RM (memory);
ROMlib_syszone = (unsigned long) memory;
ROMlib_memtop = (unsigned long) (memory + total_allocated_memory);
InitZone (0, 32, (Ptr) ((long) MR (SysZone) + init_syszone_size),
(Zone *) MR (SysZone));
beenhere = TRUE;
}
#if defined (MM_MANY_APPLZONES)
if (mm_n_applzones != 1)
{
if (munmap ((char *) MR (SysZone)
+ INIT_SYSZONE_SIZE,
applzone_memory_segment_size) == -1)
warning_errno ("unable to `munmap ()' previous applzone");
ApplZone = (THz) RM ((long) MR (SysZone)
+ INIT_SYSZONE_SIZE
+ (mm_current_applzone * INIT_APPLZONE_SIZE));
mm_current_applzone = (mm_current_applzone + 1) % mm_n_applzones;
if (mmap ((char *) MR (ApplZone), INIT_APPLZONE_SIZE,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_FIXED | MAP_PRIVATE, -1, 0) == (void *) -1)
errno_fatal ("unable to `mmap ()' new applzone");
}
else
ApplZone = (THz) RM ((long) MR (SysZone) + INIT_SYSZONE_SIZE);
#else /* !MM_MANY_APPLZONES */
ApplZone = (THz) RM ((long) MR (SysZone) + INIT_SYSZONE_SIZE);
#endif
InitApplZone ();
ApplLimit = RM ((Ptr) ((long) MR (ApplZone)
+ INIT_APPLZONE_SIZE));
EM_A7 = (long) US_TO_SYN68K(stack_end - 16 - MANDELSLOP);
MemErr = CWC (noErr);
#if ERROR_SUPPORTED_P (ERROR_MEMORY_MANAGER_SLAM)
error_set_enabled (ERROR_MEMORY_MANAGER_SLAM, old_debug_enabled_p);
#endif
}
void
SetApplBase (Ptr newbase)
{
int32 totend;
if ((char *) newbase < (char *) ZONE_BK_LIM (MR (SysZone)) + MIN_BLOCK_SIZE)
{
SET_MEM_ERR (noErr);
return;
}
/* Find out how big this makes the last bit of the system zone */
totend = (char *) newbase - (char *) ZONE_BK_LIM (MR (SysZone));
if (totend >= 24) /* Make two blocks */
{
block_header_t *newfree = ZONE_BK_LIM (MR (SysZone));
block_header_t *newlast = POINTER_TO_BLOCK (newbase);
mm_set_block_fields_offset (newfree,
FREE_BLOCK_STATE, FREE, 0,
(char *) newlast - (char *) newfree, 0);
mm_set_block_fields_offset (newlast,
FREE_BLOCK_STATE, FREE, 0,
MIN_BLOCK_SIZE, 0);
}
/* Otherwise, blow it off. There isn't room for another block at the end,
so we just let the old bkLim stand. */
ApplZone = RM ((THz) newbase);
InitApplZone ();
SET_MEM_ERR (noErr);
}
void
MoreMasters (void)
{
THz current_zone;
uint32 *handles;
int i;
MM_SLAM ("entry");
current_zone = MR (TheZone);
handles = (uint32 *) NewPtr (ZONE_MORE_MAST (current_zone)
* sizeof (uint32));
if (handles == NULL)
{
SET_MEM_ERR (memFullErr);
return;
}
handles[0] = (uint32) ZONE_HFST_FREE_X (current_zone);
ZONE_HFST_FREE_X (current_zone)
= RM ((Ptr) &handles[ZONE_MORE_MAST (current_zone) - 1]);
for (i = ZONE_MORE_MAST (current_zone) - 1; i > 0; i--)
handles[i] = RM ((uint32) &handles[i - 1]);
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
return;
}
#if !defined (NDEBUG)
void
print_free (void)
{
printf ("%d %d\n", CL (MR(ApplZone)->zcbFree), CL (MR(SysZone)->zcbFree));
}
#endif
void
InitZone (ProcPtr pGrowZone, int16 cMoreMasters,
Ptr limitPtr, THz zone)
{
block_header_t *last_block;
block_header_t *first_block;
/* following line is needed for PPC version of Illustrator 5.5
TODO: check mac carefully to see how they handle the final block */
limitPtr = limitPtr - 8;
last_block = (block_header_t *) ((char *) limitPtr - MIN_BLOCK_SIZE);
first_block = ZONE_HEAP_DATA (zone);
zone->bkLim = RM ((Ptr) last_block);
zone->purgePtr = CLC_NULL;
zone->hFstFree = CLC_NULL;
zone->zcbFree = CL ((uint32) limitPtr - (uint32) zone - 64);
zone->gzProc = RM (pGrowZone);
zone->moreMast = CW (cMoreMasters);
zone->flags = CWC (0);
zone->minCBFree = CWC (0);
zone->purgeProc = CLC_NULL;
zone->cntRel = zone->cntNRel = zone->cntEmpty = zone->cntHandles
= CWC (0);
/* hypercard checks byte `30' (the high byte of the `maxNRel' field)
of the Zone structure to determine if it can set the alloc
pointer to the address of a non-relocatable block it just
`DisposePtr ()'ed (which is allowed in 24bit zones).
#### testing on the mac to see what the `max*' fields actually
mean in a 32bit zone is required, but this is a good a guess as
anything */
zone->maxRel = zone->maxNRel = CWC (-1);
#if 0
zone->sparePtr = CLC ((Ptr) 0x83d2); /* From experimentation */
#else
zone->sparePtr = CLC (0); /* Better safe than sorry */
#endif
zone->allocPtr = RM ((Ptr) first_block);
mm_set_block_fields_offset (first_block,
FREE_BLOCK_STATE, FREE, 0,
(char *) last_block - (char *) first_block, 0);
mm_set_block_fields_offset (last_block,
FREE_BLOCK_STATE, FREE, 0,
MIN_BLOCK_SIZE, 0);
TheZone = RM (zone);
MoreMasters ();
MM_SLAM_ZONE (zone, "exit");
SET_MEM_ERR (noErr);
}
THz
GetZone (void)
{
MM_SLAM ("entry");
SET_MEM_ERR (noErr);
return MR (TheZone);
}
void
SetZone (THz hz)
{
MM_SLAM ("entry");
TheZone = RM (hz);
SET_MEM_ERR (noErr);
}
Handle
_NewEmptyHandle_flags (boolean_t sys_p)
{
THz save_zone, current_zone;
Handle h;
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
for (;;)
{
h = (Handle) ZONE_HFST_FREE (current_zone);
if (h)
{
ZONE_HFST_FREE_X (current_zone) = h->p;
h->p = NULL;
SET_MEM_ERR (noErr);
break;
}
else
{
MoreMasters ();
if (MemError () != noErr)
{
SET_MEM_ERR (memFullErr);
break;
}
}
}
MM_SLAM ("exit");
TheZone = save_zone;
return h;
}
Handle
_NewHandle_flags (Size size, boolean_t sys_p, boolean_t clear_p)
{
Handle newh;
block_header_t *block;
THz save_zone, current_zone;
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
newh = NewEmptyHandle ();
if (newh == NULL)
{
SET_MEM_ERR (memFullErr);
goto done;
}
size += HDRSIZE;
if (ROMlib_relalloc (size, &block) != noErr)
{
DisposHandle (newh);
newh = NULL;
SET_MEM_ERR (memFullErr);
goto done;
}
gui_assert (block < ZONE_BK_LIM (current_zone));
ROMlib_setupblock (block, size, REL, newh, 0);
newh->p = BLOCK_DATA_X (block);
if (clear_p)
memset (BLOCK_DATA (block), 0, size - HDRSIZE);
SET_MEM_ERR (noErr);
/* fall through */
done:
MM_SLAM ("exit");
TheZone = save_zone;
return newh;
}
#define TTS_HACK (ROMlib_options & ROMLIB_DISPOSHANDLE_HACK_BIT)
void
DisposHandle (Handle h)
{
MM_SLAM ("entry");
if (TTS_HACK &&
h == (Handle) (CL (*(long *)SYN68K_TO_US (256)) + ROMlib_offset))
h = 0;
if (h)
{
block_header_t *block;
THz current_zone;
THz save_zone;
save_zone = TheZone;
current_zone = HandleZone (h);
if (!current_zone)
{
SET_MEM_ERR (memAZErr);
return;
}
TheZone = RM (current_zone);
block = HANDLE_TO_BLOCK (h);
if (h->p && BLOCK_TO_HANDLE (MR (TheZone), block) != h)
{
TheZone = save_zone;
SET_MEM_ERR (memAZErr);
return;
}
if (block)
{
if (USE (block) == FREE)
{
TheZone = save_zone;
SET_MEM_ERR (memWZErr);
return;
}
if (HANDLE_STATE (h, block) & RSRCBIT)
{
if (h == (Handle) ROMlib_phoney_name_string)
{
SET_MEM_ERR (memAZErr);
return;
}
warning_unexpected ("disposing resource handle");
}
ROMlib_freeblock (block);
}
h->p = ZONE_HFST_FREE_X (current_zone);
ZONE_HFST_FREE_X (current_zone) = RM ((Ptr) h);
TheZone = save_zone;
}
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
Size
GetHandleSize (Handle h)
{
block_header_t *block;
Size retval;
MM_SLAM ("entry");
block = HANDLE_TO_BLOCK (h);
if (block == NULL)
{
SET_MEM_ERR (nilHandleErr);
retval = 0;
}
else if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return 0;
}
else
{
SET_MEM_ERR (noErr);
retval = LSIZE (block);
}
return retval;
}
void
SetHandleSize (Handle h, Size newsize)
{
block_header_t *block;
int32 oldpsize;
THz save_zone, current_zone;
boolean_t save_memnomove_p;
unsigned int state;
#if defined (X) /* what about NEXTSTEP? */
if (h == MR (TEScrpHandle))
WeOwnScrapX ();
#endif
MM_SLAM ("entry");
newsize += HDRSIZE; /* Header */
block = HANDLE_TO_BLOCK (h);
if (!block)
{
SET_MEM_ERR (nilHandleErr);
return;
}
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
save_zone = TheZone;
current_zone = HandleZone (h);
TheZone = RM (current_zone);
state = HANDLE_STATE (h, block);
oldpsize = PSIZE (block);
if (newsize <= oldpsize)
ROMlib_setupblock (block, newsize, REL, h, state);
else
{
block_header_t *nextblock;
block_header_t *newblock;
nextblock = BLOCK_NEXT (block);
/* First try and grow it forward */
save_memnomove_p = ROMlib_memnomove_p;
if (USE (nextblock) == REL && ROMlib_locked (block))
ROMlib_memnomove_p = FALSE;
if (ROMlib_makespace (&nextblock, newsize - oldpsize))
{
ROMlib_memnomove_p = save_memnomove_p;
ZONE_ZCB_FREE_X (current_zone)
= CL (ZONE_ZCB_FREE (current_zone) - PSIZE (nextblock));
SETPSIZE (block, oldpsize + PSIZE (nextblock));
SETSIZEC (block, 0);
ROMlib_setupblock (block, newsize, REL, h, state);
}
else
{
ROMlib_memnomove_p = save_memnomove_p;
/* At this point, if the block is locked, we lose */
if (ROMlib_locked (block))
goto bad;
GZRootHnd = RM (h);
/* Now try and find the space elsewhere */
if (ROMlib_relalloc (newsize, &newblock))
{
GZRootHnd = NULL;
goto bad;
}
GZRootHnd = NULL;
ROMlib_moveblock (block, newblock, newsize);
}
}
/* And now we're done. */
TheZone = save_zone;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return;
bad:
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (memFullErr);
}
#define HANDLE_IN_ZONE_P(handle, z) \
( (unsigned long) (handle) >= (unsigned long) MR (z) \
&& (unsigned long) (handle) < (unsigned long) ZONE_BK_LIM (MR (z)))
#define PTR_IN_ZONE_P(ptr, z) \
( (unsigned long) (ptr) >= (unsigned long) MR (z) \
&& (unsigned long) (ptr) <= (unsigned long) ZONE_BK_LIM (MR (z)))
THz
HandleZone (Handle h)
{
THz zone;
block_header_t *block;
boolean_t applzone_p;
boolean_t syszone_p;
MM_SLAM ("entry");
if (h == NULL)
{
SET_MEM_ERR (nilHandleErr);
return NULL;
}
applzone_p = FALSE;
syszone_p = FALSE;
if (HANDLE_IN_ZONE_P (h, ApplZone))
{
Ptr p;
p = STARH (h);
if (p && !PTR_IN_ZONE_P (p, ApplZone))
{
SET_MEM_ERR (memAZErr);
return NULL;
}
applzone_p = TRUE;
}
else if (HANDLE_IN_ZONE_P (h, SysZone))
{
Ptr p;
p = STARH (h);
if (p && !PTR_IN_ZONE_P (p, SysZone))
{
SET_MEM_ERR (memAZErr);
return NULL;
}
syszone_p = TRUE;
}
/*
* Prevent us from returning a zone when a dereference of the handle would
* cause a segmentation fault.
*
* NOTE: we don't use the SysZone or MemTop low-memory globals, because
* it's possible that they have been modified in such a way that
* this test would fail even with an address that can legitimately
* be dereferenced.
*/
else if (!VALID_ADDRESS (h))
{
SET_MEM_ERR (memAZErr);
return NULL;
}
block = HANDLE_TO_BLOCK (h);
if (block && USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return NULL;
}
if (block)
zone = (THz) ((int32) h - (int32) BLOCK_LOCATION_OFFSET (block));
else if (applzone_p)
zone = MR (ApplZone);
else if (syszone_p)
zone = MR (SysZone);
else
zone = MR (TheZone);
SET_MEM_ERR (noErr);
return zone;
}
Handle
_RecoverHandle_flags (Ptr p, boolean_t sys_p)
{
block_header_t *block;
THz zones[3];
Handle h;
int i;
MM_SLAM ("entry");
block = POINTER_TO_BLOCK (p);
if (sys_p)
{
zones[0] = MR (SysZone);
zones[1] = MR (TheZone);
}
else
{
zones[0] = MR (TheZone);
zones[1] = MR (SysZone);
}
zones[2] = MR (ApplZone);
for (i = 0; i < 3; i++)
{
h = BLOCK_TO_HANDLE (zones[i], block);
if ((uint32) h > (uint32) zones[i]
&& (uint32) h < (uint32) ZONE_BK_LIM (zones[i])
&& STARH (h) == p)
break;
}
if (i < 3)
SET_MEM_ERR (noErr);
else
{
h = 0;
#warning FIND OUT WHAT A REAL MAC DOES HERE
}
return h;
}
void
ReallocHandle (Handle h, Size size)
{
block_header_t *oldb, *newb;
int32 newsize;
THz save_zone;
THz current_zone;
unsigned int state;
MM_SLAM ("entry");
if (h == NULL)
warning_unexpected ("called with NULL_STRING handle");
oldb = HANDLE_TO_BLOCK (h);
save_zone = TheZone;
current_zone = HandleZone (h);
TheZone = RM (current_zone);
size += HDRSIZE;
if (!oldb)
state = 0;
else
{
if (ROMlib_locked (oldb))
{
TheZone = save_zone;
SET_MEM_ERR (memPurErr);
return;
}
if (USE (oldb) == FREE)
{
TheZone = save_zone;
SET_MEM_ERR (memWZErr);
return;
}
state = BLOCK_STATE (oldb);
if (PSIZE (oldb) >= (uint32) size)
{
ROMlib_setupblock (oldb, size, REL, h, state);
goto done;
}
newb = BLOCK_NEXT (oldb);
if (USE (newb) == FREE)
{
ROMlib_coalesce (newb);
newsize = PSIZE (oldb) + PSIZE (newb);
if (newsize >= size)
{
SETPSIZE (oldb, newsize);
ZONE_ZCB_FREE_X (current_zone)
= CL (ZONE_ZCB_FREE (current_zone) - PSIZE (newb));
ROMlib_setupblock (oldb, size, REL, h, state);
goto done;
}
}
}
if (ROMlib_relalloc (size, &newb))
{
TheZone = save_zone;
SET_MEM_ERR (memFullErr);
return;
}
ROMlib_setupblock (newb, size, REL, h, state);
SETMASTER (h, BLOCK_DATA (newb));
if (oldb)
ROMlib_freeblock (oldb);
/* fall through */
done:
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
#if 1 && !defined(NDEBUG)
int do_save_alloc = 0;
#endif
Ptr
_NewPtr_flags (Size size, boolean_t sys_p, boolean_t clear_p)
{
Ptr p;
block_header_t *b;
THz save_zone, current_zone;
#if 1
block_header_t *save_alloc_ptr;
#endif
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
size += HDRSIZE;
#if 1
save_alloc_ptr = (typeof (save_alloc_ptr)) ZONE_ALLOC_PTR_X (current_zone);
#endif
ZONE_ALLOC_PTR_X (current_zone) = CLC_NULL;
ResrvMem (size);
if (ROMlib_relalloc (size, &b))
{
#if 0
ZONE_ALLOC_PTR_X (current_zone) = save_alloc_ptr;
#endif
TheZone = save_zone;
SET_MEM_ERR (memFullErr);
MM_SLAM ("exit");
return NULL;
}
#if 1 && !defined(NDEBUG)
if (do_save_alloc)
ZONE_ALLOC_PTR_X (current_zone)
= (typeof (ZONE_ALLOC_PTR_X (current_zone))) save_alloc_ptr;
else
checkallocptr ();
#endif
gui_assert (b < ZONE_BK_LIM (current_zone));
ROMlib_setupblock (b, size, NREL, 0);
p = BLOCK_DATA (b);
if (clear_p)
memset (p, 0, size - HDRSIZE);
TheZone = save_zone;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return p;
}
void
DisposPtr (Ptr p)
{
MM_SLAM ("entry");
if (p)
{
block_header_t *block;
THz zone;
block = POINTER_TO_BLOCK (p);
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
zone = PtrZone (p);
if (zone)
{
ZONE_SAVE_EXCURSION
(RM (zone),
{
ROMlib_freeblock (block);
});
}
else
warning_unexpected (NULL_STRING);
}
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
}
Size
GetPtrSize (Ptr p)
{
block_header_t *block;
MM_SLAM ("entry");
block = POINTER_TO_BLOCK (p);
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return 0;
}
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return LSIZE (block);
}
void
SetPtrSize (Ptr p, Size newsize)
{
block_header_t *block;
LONGINT oldpsize;
THz save_zone, current_zone;
MM_SLAM ("entry");
if (p == NULL)
warning_unexpected ("attempt to set NULL_STRING pointer size");
newsize += HDRSIZE;
block = POINTER_TO_BLOCK (p);
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
return;
}
save_zone = TheZone;
current_zone = PtrZone (p);
if (!current_zone)
{
warning_unexpected (NULL_STRING);
SET_MEM_ERR (memWZErr); /* Not really sure what we should return in
this case. It's not like the Mac has any
decent error semantics */
}
else
{
TheZone = RM (current_zone);
oldpsize = PSIZE (block);
if (newsize <= oldpsize)
ROMlib_setupblock (block, newsize, NREL, 0);
else
{
block_header_t *nextblock;
nextblock = BLOCK_NEXT (block);
/* First try and grow it forward */
if (ROMlib_makespace (&nextblock, newsize - oldpsize))
{
ZONE_ZCB_FREE_X (current_zone)
= CL (ZONE_ZCB_FREE_X (current_zone) - PSIZE (nextblock));
SETPSIZE (block, oldpsize + PSIZE (nextblock));
SETSIZEC (block, 0);
ROMlib_setupblock (block, newsize, NREL, 0);
}
else
{
TheZone = save_zone;
SET_MEM_ERR (memFullErr);
return;
}
}
}
/* And now we're done. */
TheZone = save_zone;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
}
PRIVATE boolean_t
legit_addr_p (void *addr)
{
boolean_t retval;
retval = TRUE; /* all addresses are valid for now */
return retval;
}
PRIVATE boolean_t
legit_zone_p (THz zone)
{
boolean_t retval;
if (!legit_addr_p (zone))
retval = FALSE;
else
{
block_header_t *blockp;
blockp = ZONE_HEAP_DATA (zone);
retval = (THz) blockp->location_u == RM (zone);
}
return retval;
}
THz
PtrZone (Ptr p)
{
block_header_t *block;
THz zone;
MM_SLAM ("entry");
if (p == NULL)
warning_unexpected ("attempt to set NULL_STRING pointer size");
block = POINTER_TO_BLOCK (p);
if (USE (block) == FREE)
{
SET_MEM_ERR (memWZErr);
/* don't count on this value (IMII-38) */
return NULL;
}
zone = (THz) BLOCK_LOCATION_ZONE (block);
if (!legit_zone_p (zone))
{
SET_MEM_ERR (memWZErr); /* not sure what this should be */
return NULL;
}
SET_MEM_ERR (noErr);
return zone;
}
int32
_FreeMem_flags (boolean_t sys_p)
{
uint32 freespace;
MM_SLAM ("entry");
if (sys_p)
freespace = ZONE_ZCB_FREE (MR (SysZone));
else
freespace = ZONE_ZCB_FREE (MR (TheZone));
SET_MEM_ERR (noErr);
return freespace;
}
Size
_MaxMem_flags (Size *growp, boolean_t sys_p)
{
block_header_t *b;
THz save_zone;
THz current_zone;
uint32 biggestfree;
uint32 sizesofar;
block_header_t *startb;
Size grow;
enum { SEARCHING, COUNTING } state;
MM_SLAM ("entry");
sizesofar = 0;
startb = 0;
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
/* Purge everyone */
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
Handle h;
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
h = BLOCK_TO_HANDLE (current_zone, b);
if (USE (b) == REL
&& (HANDLE_STATE (h, b) & (LOCKBIT | PURGEBIT)) == PURGEBIT)
EmptyHandle (h);
}
/* Compact the whole thing */
CompactMem (0x7FFFFFFF);
/* Compress the free blocks */
state = SEARCHING;
biggestfree = 0;
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
if (state == SEARCHING)
{
if (USE (b) == FREE)
{
startb = b;
sizesofar = PSIZE (b);
state = COUNTING;
}
}
else
{
if (USE (b) == FREE)
sizesofar += PSIZE (b);
else
{
SETPSIZE (startb, sizesofar);
if (ZONE_ALLOC_PTR (current_zone) > startb
&& ((char *) ZONE_ALLOC_PTR (current_zone)
< (char *) startb + sizesofar))
ZONE_ALLOC_PTR_X (current_zone) = RM ((Ptr) startb);
if (sizesofar > biggestfree)
biggestfree = sizesofar;
state = SEARCHING;
}
}
}
if (state == COUNTING)
{
SETPSIZE (startb, sizesofar);
if (ZONE_ALLOC_PTR (current_zone) > startb
&& ((char *) ZONE_ALLOC_PTR (current_zone)
< (char *) startb + sizesofar))
ZONE_ALLOC_PTR_X (current_zone) = RM ((Ptr) startb);
if (sizesofar > biggestfree)
biggestfree = sizesofar;
}
if (TheZone == ApplZone)
grow = (uint32) MR (ApplLimit) - (uint32) HEAPEND;
else
grow = 0;
TheZone = save_zone;
*growp = grow;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return biggestfree;
}
Size
_CompactMem_flags (Size sizeneeded, boolean_t sys_p)
{
int32 amtfree;
block_header_t *src, *target, *ap;
THz save_zone;
THz current_zone;
boolean_t startfront_p;
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
/* We've seen HyperCard load allocPtr with -8 before ... yahoo.
Specifically, HC 2.1 would do this after you use the Chart making
stack to make a chart and then you try to "Go Home" via the menu */
ap = ZONE_ALLOC_PTR (current_zone);
if (ap >= ZONE_HEAP_DATA (current_zone)
&& ap <= ZONE_BK_LIM (current_zone))
src = target = ap;
else
src = target = ZONE_HEAP_DATA (current_zone);
startfront_p = (src == ZONE_HEAP_DATA (current_zone));
repeat:
ZONE_ALLOC_PTR_X (current_zone) = CLC_NULL;
amtfree = 0;
while (src != ZONE_BK_LIM (current_zone)
&& amtfree < sizeneeded)
{
if (USE (src) == REL && !ROMlib_locked (src))
{
if (src == target)
src = target = BLOCK_NEXT (target);
else if (src < target)
gui_abort ();
else
{
*target = *src;
SETMASTER (BLOCK_TO_HANDLE (current_zone, src),
BLOCK_DATA (target));
BlockMove (BLOCK_DATA (src), BLOCK_DATA (target), LSIZE (src));
src = (block_header_t *) ((char *) src + PSIZE (target));
target = BLOCK_NEXT (target);
}
}
else if (USE (src) == FREE)
src = BLOCK_NEXT (src);
else
{
if (src > target)
{
int32 src_target_diff = (char *) src - (char *) target;
mm_set_block_fields_offset (target,
FREE_BLOCK_STATE, FREE, 0,
src_target_diff, 0);
if (src_target_diff > amtfree)
{
amtfree = src_target_diff;
if (!ZONE_ALLOC_PTR_X (current_zone))
ZONE_ALLOC_PTR_X (current_zone) = (Ptr) RM (target);
}
}
src = target = BLOCK_NEXT (src);
}
}
/* If we got out because we hit the end, do the last case above for
the final free block. */
if (src == ZONE_BK_LIM (current_zone) && src > target)
{
int32 src_target_diff = (char *) src - (char *) target;
mm_set_block_fields_offset (target,
FREE_BLOCK_STATE, FREE, 0,
src_target_diff, 0);
if (src_target_diff > amtfree)
{
amtfree = src_target_diff;
if (!ZONE_ALLOC_PTR_X (current_zone))
ZONE_ALLOC_PTR_X (current_zone) = RM ((Ptr) target);
}
}
if (amtfree < sizeneeded && !startfront_p)
{
startfront_p = TRUE;
src = target = ZONE_HEAP_DATA (current_zone);
goto repeat;
}
TheZone = save_zone;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return amtfree;
}
void
_ResrvMem_flags (Size needed, boolean_t sys_p)
{
THz save_zone;
THz current_zone;
block_header_t *b;
Size free;
long avail;
boolean_t already_maxed_p;
MM_SLAM ("entry");
if (needed <= 0)
{
SET_MEM_ERR (noErr);
return;
}
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
already_maxed_p = FALSE;
again:
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
if (ROMlib_makespace (&b, needed))
{
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
return;
}
}
avail = MaxMem (&free);
if (avail >= needed && !already_maxed_p)
{
already_maxed_p = TRUE;
goto again;
}
if (free >= needed)
{
/* relalloc will do the actual extension. */
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
return;
}
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (memFullErr);
}
void
_PurgeMem_flags (Size sizeneeded, boolean_t sys_p)
{
long amount_free, max_free;
block_header_t *b;
THz save_zone;
THz current_zone;
MM_SLAM ("entry");
amount_free = 0;
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
max_free = 0;
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
Handle h;
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
h = BLOCK_TO_HANDLE (current_zone, b);
if (USE (b) == REL
&& (HANDLE_STATE (h, b) & (LOCKBIT | PURGEBIT)) == PURGEBIT)
EmptyHandle (h);
amount_free = ROMlib_amtfree (b);
if (amount_free >= max_free)
max_free = amount_free;
if (amount_free >= sizeneeded)
break;
}
TheZone = save_zone;
if (amount_free < sizeneeded)
SET_MEM_ERR (memFullErr);
else
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
}
PRIVATE void
BlockMove_and_possibly_flush_cache (Ptr src, Ptr dst, Size cnt,
boolean_t flush_p)
{
if (cnt > 0)
{
/* ugly, but probably better than crashing when we try to
dereference 0 */
if (!dst)
dst = (Ptr) SYN68K_TO_US (dst);
if (!src)
src = (Ptr) SYN68K_TO_US (src);
memmove_transfer (dst, src, cnt);
if (flush_p)
ROMlib_destroy_blocks ((syn68k_addr_t) US_TO_SYN68K(dst), cnt, TRUE);
}
/* don't use `SET_MEM_ERR' since that will do a heap slam and we
will lose */
MemErr = CWC (noErr);
}
void
BlockMove (Ptr src, Ptr dst, Size cnt)
{
BlockMove_and_possibly_flush_cache (src, dst, cnt, TRUE);
}
void
BlockMoveData (Ptr src, Ptr dst, Size cnt)
{
BlockMove_and_possibly_flush_cache (src, dst, cnt, FALSE);
}
void
BlockMove_the_trap (Ptr src, Ptr dst, Size cnt, boolean_t flush_p)
{
MM_SLAM ("entry");
BlockMove_and_possibly_flush_cache (src, dst, cnt, flush_p);
MM_SLAM ("exit");
}
void
MaxApplZone (void)
{
MM_SLAM ("entry");
/* #warning MaxApplZone does not do anything -- we start out with max */
SET_MEM_ERR (noErr);
}
void
MoveHHi (Handle h)
{
MM_SLAM ("entry");
/* Oh No! More Lemmings appears to assume that MoveHHi will
* flush the cache. This is not an unreasonable assumption, since
* large BlockMove's are guaranteed to flush the cache, and
* MoveHHi of a large piece of memory would typically involve a
* big BlockMove. Since MoveHHi isn't called very often,
* and is expected to be fairly slow, we use this opportunity
* to flush the cache. We only nuke code whose checksums
* have changed, for speed.
*
* We make an exception for Microsoft Word, because the spelling checker
* will be real slow if we don't.
*/
if (ROMlib_creator != TICK ("MSWD") && ROMlib_creator != TICK ("ddOr"))
ROMlib_destroy_blocks (0, ~0, TRUE);
/* #### there used to be a lot of code here; but it was unused and
returned noErr #if !MOVEHIWORKS -- see the rcsfile for details */
/* #warning MoveHHi not implemented */
/* #### just emits too many unecessary warnings
warning_unimplemented (""); */
SET_MEM_ERR (noErr);
}
int32
_MaxBlock_flags (boolean_t sys_p)
{
THz save_zone;
THz current_zone;
int32 max_free;
int32 total_free;
block_header_t *b;
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
max_free = total_free = 0;
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
if (USE (b) == FREE)
total_free += PSIZE (b);
else if (USE (b) == NREL || ROMlib_locked (b))
{
if (total_free > max_free)
max_free = total_free;
total_free = 0;
}
}
TheZone = save_zone;
SET_MEM_ERR (noErr);
MM_SLAM ("exit");
return MAX (total_free, max_free) - HDRSIZE;
}
void
_PurgeSpace_flags (Size *total_out, Size *contig_out, boolean_t sys_p)
{
THz save_zone, current_zone;
int32 total_free;
int32 this_contig;
int32 max_contig;
block_header_t *b;
MM_SLAM ("entry");
save_zone = TheZone;
if (sys_p)
TheZone = SysZone;
current_zone = MR (TheZone);
total_free = this_contig = max_contig = 0;
for (b = ZONE_HEAP_DATA (current_zone);
b != ZONE_BK_LIM (current_zone);
b = BLOCK_NEXT (b))
{
Handle h;
if (PSIZE (b) < MIN_BLOCK_SIZE)
HEAP_DEATH ();
h = BLOCK_TO_HANDLE (current_zone, b);
if (USE (b) == FREE
|| (USE (b) == REL
&& (HANDLE_STATE (h, b) & (LOCKBIT | PURGEBIT)) == PURGEBIT))
{
this_contig += PSIZE (b);
total_free += PSIZE (b);
}
else if (USE (b) == NREL || ROMlib_locked (b))
{
if (this_contig > max_contig)
max_contig = this_contig;
this_contig = 0;
}
}
TheZone = save_zone;
SET_MEM_ERR (noErr);
*total_out = total_free - HDRSIZE;
*contig_out = MAX (this_contig, max_contig) - HDRSIZE;
MM_SLAM ("exit");
}
Size
StackSpace (void)
{
int32 fp;
MM_SLAM ("entry");
fp = (int32) SYN68K_TO_US (EM_A7);
/* Stack pointer on return is fp + 8 (4 for old fp, 4 for return
address) */
SET_MEM_ERR (noErr);
return (fp + 8) - (int32) HEAPEND;
}
void
SetApplLimit (Ptr new_limit)
{
/* NOTE TO CLIFF:
We can't do any sanity checks here (not even a brk()), since
the ApplLimit might be directly changed by programs, and we have
to deal with that. */
/* Making the ApplLimit too small has no effect (IMII-30), and making
it too big shouldn't cause a problem until the excess memory starts
being used (by incrementation of HEAPEND). */
MM_SLAM ("entry");
ApplLimit = RM (new_limit);
HeapEnd = RM (new_limit - MIN_BLOCK_SIZE);
SET_MEM_ERR (noErr);
}
void
SetGrowZone (ProcPtr newgz)
{
MM_SLAM ("entry");
ZONE_GZ_PROC_X (MR (TheZone)) = RM (newgz);
SET_MEM_ERR (noErr);
}
void
EmptyHandle (Handle h)
{
THz save_zone, current_zone;
block_header_t *b;
MM_SLAM ("entry");
b = HANDLE_TO_BLOCK (h);
if (b == NULL)
{
SET_MEM_ERR (noErr);
return;
}
save_zone = TheZone;
current_zone = HandleZone (h);
TheZone = RM (current_zone);
if (ROMlib_locked (b))
{
TheZone = save_zone;
SET_MEM_ERR (memPurErr);
return;
}
if (USE (b) == FREE)
{
TheZone = save_zone;
SET_MEM_ERR (memWZErr);
return;
}
if (ZONE_PURGE_PROC_X (current_zone))
{
uint32 saved0, saved1, saved2, savea0, savea1;
ROMlib_hook (memory_purgeprocnumber);
saved0 = EM_D0;
saved1 = EM_D1;
saved2 = EM_D2;
savea0 = EM_A0;
savea1 = EM_A1;
PUSHADDR ((long) US_TO_SYN68K (h));
CALL_EMULATOR ((syn68k_addr_t)
US_TO_SYN68K (ZONE_PURGE_PROC (current_zone)));
EM_D0 = saved0;
EM_D1 = saved1;
EM_D2 = saved2;
EM_A0 = savea0;
EM_A1 = savea1;
}
ROMlib_freeblock (b);
SETMASTER (h, NULL);
TheZone = save_zone;
MM_SLAM ("exit");
SET_MEM_ERR (noErr);
}
/* Fluff for Cliff */
void
ROMlib_installhandle (Handle sh, Handle dh)
{
THz save_zone;
MM_SLAM ("entry");
save_zone = TheZone;
TheZone = RM (HandleZone (dh));
if (TRUE
|| ROMlib_locked (HANDLE_TO_BLOCK (dh))
|| HandleZone (sh) != MR (TheZone))
{
Size size;
size = GetHandleSize (sh);
SetHandleSize (dh, size);
if (MemErr == CWC (noErr))
BlockMove (STARH (sh), STARH (dh), size);
DisposHandle (sh);
}
else
{
block_header_t *db = HANDLE_TO_BLOCK (dh);
block_header_t *sb = HANDLE_TO_BLOCK (sh);
ROMlib_freeblock (db);
SETMASTER (dh, STARH (sh));
BLOCK_LOCATION_OFFSET_X (sb) = CL ((uint32) dh - (uint32) MR (TheZone));
sh->p = (Ptr) ZONE_HFST_FREE_X (MR (TheZone));
ZONE_HFST_FREE_X (MR (TheZone)) = RM ((Ptr) sh);
}
TheZone = save_zone;
MM_SLAM ("exit");
}
OSErr
MemError (void)
{
MM_SLAM ("entry");
return CW (MemErr);
}
THz
SystemZone (void)
{
MM_SLAM ("entry");
return MR (SysZone);
}
THz
ApplicZone (void)
{
MM_SLAM ("entry");
return MR (ApplZone);
}
/* Like NewHandle, but fills in the newly allocated memory by copying
* data from the supplied pointer. Use the NewHandle_copy_ptr and
* NewHandleSys_copy_ptr macros to access this function.
*/
Handle
_NewHandle_copy_ptr_flags (Size size, const void *data_to_copy,
boolean_t sys_p)
{
Handle h;
h = _NewHandle_flags (size, sys_p, FALSE);
if (MemErr == CWC (noErr))
memcpy (STARH (h), data_to_copy, size);
return h;
}
/* Like NewHandle, but fills in the newly allocated memory by copying
* data from the supplied Handle. Use the NewHandle_copy_handle and
* NewHandleSys_copy_handle macros to access this function.
*/
Handle
_NewHandle_copy_handle_flags (Size size, Handle data_to_copy, boolean_t sys_p)
{
Handle h;
if (GetHandleSize (data_to_copy) < size)
warning_unexpected ("Not enough bytes to copy!");
h = _NewHandle_flags (size, sys_p, FALSE);
if (MemErr == CWC (noErr))
memcpy (STARH (h), STARH (data_to_copy), size);
return h;
}
/* Like NewPtr, but fills in the newly allocated memory by copying
* data from the supplied pointer. Use the NewPtr_copy_ptr and
* NewPtrSys_copy_ptr macros to access this function.
*/
Ptr
_NewPtr_copy_ptr_flags (Size size, const void *data_to_copy,
boolean_t sys_p)
{
Ptr p;
p = _NewPtr_flags (size, sys_p, FALSE);
if (MemErr == CWC (noErr))
memcpy (p, data_to_copy, size);
return p;
}
/* Like NewPtr, but fills in the newly allocated memory by copying
* data from the supplied Handle. Use the NewPtr_copy_handle and
* NewPtrSys_copy_handle macros to access this function.
*/
Ptr
_NewPtr_copy_handle_flags (Size size, Handle data_to_copy, boolean_t sys_p)
{
Ptr p;
if (GetHandleSize (data_to_copy) < size)
warning_unexpected ("Not enough bytes to copy!");
p = _NewPtr_flags (size, sys_p, FALSE);
if (MemErr == CWC (noErr))
memcpy (p, STARH (data_to_copy), size);
return p;
}
Reference in New Issue View Git Blame Copy Permalink