root/trunk/orca/array.c

/*============================================================================
    ORCA Interpreter
    Copyright (C) 2005-2006  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include "os.h"
#include "ovalue.h"


void orArrayInit( OArray* arr, int elemSize, int elemCount )
{
    long size = elemSize * elemCount;
    if( size )
    {
        arr->buf = memAlloc( size );
        if( arr->buf )
            arr->avail = elemCount;
        else
            arr->avail = 0;
    }
    else
    {
        arr->buf   = 0;
        arr->avail = 0;
    }
    arr->used  = 0;
}


/**
  Frees the memory pointed to by arr->buf.
*/
void orArrayFree( OArray* arr )
{
    assert( arr );

    if( arr->buf )
    {
        memFree( arr->buf );
        arr->buf   = 0;
        arr->avail = 0;
        arr->used  = 0;
    }
}


/**
  Allocates enough memory to hold elemCount elements.
  arr->used is not changed.
*/
void orArrayReserve( OArray* arr, int elemSize, int elemCount )
{
    assert( arr );
    assert( arr->avail > -1 );

    if( elemCount > arr->avail )
    {
        int count;
        void* buf;

        /* Double the buffer size (unless that is not big enough). */
        count = arr->avail * 2;
        if( count < elemCount )
        {
            count = (elemCount < 8) ? 8 : elemCount;
        }

        buf = memAlloc( elemSize * count );
        assert( buf );
        if( buf )
        {
            if( arr->buf )
            {
                if( arr->used ) 
                    memCpy( buf, arr->buf, elemSize * arr->used );
                memFree( arr->buf );
            }
            arr->buf   = buf;
            arr->avail = count;
        }
    }
}


/**
  Remove count elements from the array starting at index.
*/
void orArrayErase( OArray* arr, int elemSize, int index, int count )
{
    assert( arr );
    assert( index < arr->used );

    if( (index + count) >= arr->used )
    {
        arr->used = index;
        return;
    }

    if( elemSize == 1 )
    {
        char* buf;
        char* src;
        char* end;

        buf = arr->charArray + index;
        src = buf + count;
        end = arr->charArray + arr->used;

        while( src != end )
            *buf++ = *src++;
    }
    else if( elemSize == 16 )
    {
#if __WORDSIZE == 64
        uint64_t* buf;
        uint64_t* src;
        uint64_t* end;

        buf = ((uint64_t*) arr->buf) + (index * 2);
        src = buf + (count * 2);
        end = ((uint64_t*) arr->buf) + (arr->used * 2);

        while( src != end )
        {
            *buf++ = *src++;
            *buf++ = *src++;
        }
#else
        uint32_t* buf;
        uint32_t* src;
        uint32_t* end;

        buf = ((uint32_t*) arr->buf) + (index * 4);
        src = buf + (count * 4);
        end = ((uint32_t*) arr->buf) + (arr->used * 4);

        while( src != end )
        {
            *buf++ = *src++;
            *buf++ = *src++;
            *buf++ = *src++;
            *buf++ = *src++;
        }
#endif
    }
    else
    {
        char* buf; 
        buf = arr->charArray + (elemSize * index);
        memMove( buf, buf + (elemSize * count),
                 elemSize * (arr->used - index - count) );
    }

    arr->used -= count;
}


/*EOF*/