137 lines
3.1 KiB
C
137 lines
3.1 KiB
C
/*
|
|
Copyright 2015 Wolfgang Thaller.
|
|
|
|
This file is part of Retro68.
|
|
|
|
Retro68 is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Retro68 is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
Under Section 7 of GPL version 3, you are granted additional
|
|
permissions described in the GCC Runtime Library Exception, version
|
|
3.1, as published by the Free Software Foundation.
|
|
|
|
You should have received a copy of the GNU General Public License and
|
|
a copy of the GCC Runtime Library Exception along with this program;
|
|
see the files COPYING and COPYING.RUNTIME respectively. If not, see
|
|
<http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <reent.h>
|
|
#include <string.h>
|
|
#include <MacMemory.h>
|
|
|
|
void referenceMyMalloc(void) {}
|
|
|
|
void *_malloc_r(struct _reent *reent_ptr, size_t sz)
|
|
{
|
|
Ptr p = NewPtr(sz);
|
|
|
|
if(!p)
|
|
reent_ptr->_errno = ENOMEM;
|
|
|
|
return p;
|
|
}
|
|
void *_calloc_r(struct _reent *reent_ptr, size_t sz, size_t sz2)
|
|
{
|
|
Ptr p = NewPtrClear(sz*sz2);
|
|
|
|
if(!p)
|
|
reent_ptr->_errno = ENOMEM;
|
|
|
|
return p;
|
|
}
|
|
|
|
void _free_r(struct _reent *reent_ptr, void *ptr)
|
|
{
|
|
if(ptr != NULL)
|
|
DisposePtr(ptr);
|
|
}
|
|
|
|
void *_realloc_r(struct _reent *reent_ptr, void *ptr, size_t sz)
|
|
{
|
|
if(ptr == NULL)
|
|
{
|
|
Ptr p = NewPtr(sz);
|
|
|
|
if(!p)
|
|
reent_ptr->_errno = ENOMEM;
|
|
|
|
return p;
|
|
}
|
|
else
|
|
{
|
|
MemError();
|
|
SetPtrSize(ptr, sz);
|
|
if(MemError())
|
|
{
|
|
size_t oldSz = GetPtrSize(ptr);
|
|
if(sz > oldSz)
|
|
{
|
|
void *newPtr = NewPtr(sz);
|
|
if(!newPtr)
|
|
{
|
|
reent_ptr->_errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
memcpy(newPtr, ptr, oldSz);
|
|
return newPtr;
|
|
}
|
|
else
|
|
{
|
|
reent_ptr->_errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
return ptr;
|
|
}
|
|
}
|
|
|
|
void *malloc(size_t sz)
|
|
{
|
|
return _malloc_r(_REENT, sz);
|
|
}
|
|
|
|
void free(void *p)
|
|
{
|
|
_free_r(_REENT, p);
|
|
}
|
|
|
|
void *realloc(void *ptr, size_t sz)
|
|
{
|
|
return _realloc_r(_REENT, ptr, sz);
|
|
}
|
|
|
|
void *calloc(size_t sz1, size_t sz2)
|
|
{
|
|
return _calloc_r(_REENT, sz1, sz2);
|
|
}
|
|
|
|
void *memalign(size_t alignment, size_t sz)
|
|
{
|
|
Ptr p = NewPtr(sz);
|
|
|
|
if(!p)
|
|
errno = ENOMEM;
|
|
|
|
// FIXME:
|
|
// NewPtr aligns to 4 bytes on 68020 and 68030,
|
|
// and to 16 bytes on 68040 and PowerPC.
|
|
|
|
// Do something else when more alignment is required.
|
|
// This might be hard, as adding extra overhead to all normal allocations
|
|
// just so that we can distinguish things in free() doesn't sound like it's worth it.
|
|
|
|
return p;
|
|
}
|
|
|