/*
**    Name: rmagrow.c
**
**    Date: Sun Jan  5 16:31:45 2003
**
*/

#include "rmamem.h"
#include "osheap.h"
#include "kernel.h"
#include "os.h"
#include <limits.h>
#include "cserrno.h"

static int resize_heap(void)
    {
    _kernel_swi_regs regs;
    int actual_size;

    regs.r[0] = OSDynamicArea_Read;
    regs.r[1] = rmamem_details.da;
    if (_kernel_swi(XOS_DynamicArea,&regs,&regs) != NULL)
        {
        return 1;
        }

    actual_size = regs.r[2];
    if (actual_size < rmamem_details.heap_size)
        {
        return 1;
        }
    if (actual_size == rmamem_details.heap_size)
        {
        return 0;
        }

    regs.r[0] = OSHeap_Resize;
    regs.r[1] = rmamem_details.base;
    regs.r[3] = actual_size - rmamem_details.heap_size;
    if (_kernel_swi(XOS_Heap,&regs,&regs) != NULL)
        {
        return 1;
        }

    rmamem_details.heap_size = actual_size;
    return 0;
    }

int rmamem_grow(int size)
    {
    _kernel_swi_regs regs;

    int new_size;

    if (size < 0)
        {
        errno = EINVAL;
        return 1;
        }

    if (rmamem_status == RMAMEM_DYNAMICAREA)
        {

        if (resize_heap() != 0)
            {
            return 1;
            }

        regs.r[0] = OSHeap_Describe;
        regs.r[1] = rmamem_details.base;

        if (_kernel_swi(XOS_Heap,&regs,&regs) != NULL)
            {
            return 1;
            }

        if (regs.r[2] < 0 || rmamem_details.heap_size < 0 ||
            rmamem_details.heap_size > rmamem_limit)
            {
            return 1;
            }

        if (regs.r[2] < size)
            {

/* Calculate size required */

            regs.r[0] = rmamem_details.da;

            if (size - regs.r[2] > INT_MAX - 4160)
                {
                errno = ENOMEM;
                return 1;
                }
            new_size = ((size - regs.r[2]) + 64) / 4096;
            new_size *= 4096;
            new_size += 4096;

            if (new_size > rmamem_limit - rmamem_details.heap_size)
                {
                errno = ENOMEM;
                return 1;
                }

            regs.r[1] = new_size;

            if (_kernel_swi(XOS_ChangeDynamicArea,&regs,&regs) != NULL)
                {
                return 1;
                }

            return resize_heap();

            }
        }

    return 0;
    }
