/*
 **    Name: rmarealloc.c
 **
 **    Date: Sun Jan  5 16:32:51 2003
 **
 */

#include "rmamem.h"
#include "osmodule.h"
#include "osheap.h"
#include <string.h>
#include <stdlib.h>
#include "kernel.h"
#include <limits.h>
#include "cserrno.h"

char *rmarealloc(void *ptr,size_t size)
{
    char *new_ptr,
        *old_ptr;

    size_t old_size;

    _kernel_swi_regs regs;

    if (rmamem_status == RMAMEM_UNITIALISED)
    {
        rmamem_init(RMAMEM_UNITIALISED);
    }

    if (ptr == NULL)
    {
        return rmamalloc(size);
    }

    if (size == 0)
    {
        rmafree(ptr);
        return NULL;
    }

    switch (rmamem_status)
    {
        case RMAMEM_DYNAMICAREA:

            if (size > (size_t)INT_MAX || rmamem_details.add < 0 ||
                size > (size_t)(INT_MAX - rmamem_details.add))
            {
                errno = ENOMEM;
                return NULL;
            }

            regs.r[0] = OSHeap_ReadSize;
            regs.r[1] = rmamem_details.base;
            regs.r[2] = (int)ptr;

            if (_kernel_swi(XOS_Heap,&regs,&regs) == NULL)
            {
                if (regs.r[3] < rmamem_details.add)
                {
                    errno = EINVAL;
                    return NULL;
                }
                old_size = (size_t)(regs.r[3] - rmamem_details.add);

                if (size > old_size && rmamem_grow(size + rmamem_details.add) == 1)
                {
                    errno = ENOMEM;
                    return NULL;
                }

                regs.r[0] = OSHeap_Realloc;
                regs.r[1] = rmamem_details.base;
                regs.r[2] = (int)ptr;
                regs.r[3] = (int)size - (int)old_size;
                if (_kernel_swi(XOS_Heap,&regs,&regs) == NULL)
                {
                    ptr = (char *)regs.r[2];
                }
                else
                {
                    ptr = NULL;
                }
            }
            else
            {
                ptr = NULL;
            }
            break;

        case RMAMEM_MALLOC:
            ptr = realloc(ptr,size);
            break;

        case RMAMEM_RMA:
            if (size > (size_t)(INT_MAX - 4))
            {
                errno = ENOMEM;
                return NULL;
            }
            old_ptr = (char *)ptr;

            old_ptr -= 4;

            if (*(int *)old_ptr < 0)
            {
                errno = EINVAL;
                return NULL;
            }
            old_size = (size_t)*(int *)old_ptr;

            regs.r[0] = OSModule_Realloc;
            regs.r[2] = (int)old_ptr;
            regs.r[3] = (int)size - (int)old_size;

            if (_kernel_swi(XOS_Module,&regs,&regs) == NULL)
            {
                new_ptr = (char *)regs.r[2];
                *(int *)new_ptr = size;
                return new_ptr + 4;
            }
            else
            {
                regs.r[0] = OSModule_Alloc;
                regs.r[3] = size + 4;

                if (_kernel_swi(XOS_Module,&regs,&regs) == NULL)
                {
                    new_ptr = (char *)regs.r[2];
                    if (size > old_size)
                    {
                        memcpy(new_ptr + 4,ptr,old_size);
                    }
                    else
                    {
                        memcpy(new_ptr + 4,ptr,size);
                    }

                    regs.r[0] = OSModule_Free;
                    regs.r[2] = (int)old_ptr;
                    if (_kernel_swi(XOS_Module,&regs,&regs) != NULL)
                    {
                        regs.r[0] = OSModule_Free;
                        regs.r[2] = (int)new_ptr;
                        _kernel_swi(XOS_Module,&regs,&regs);
                        errno = ENOMEM;
                        return NULL;
                    }
                    *(int *)new_ptr = size;
                    return new_ptr + 4;
                }
                else
                {
                    errno = ENOMEM;
                    return NULL;
                }
            }
            break;

        default:
            errno = EINVAL;
            return NULL;
    }

    if (ptr == NULL)
    {
        errno = ENOMEM;
    }

    return ptr;
}
