root/trunk/orca/gl/res.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 <assert.h>
#include "os.h"
#include "res.h"


static uint16_t _currentGroup = 0;


ResourceClass* _resClass[ MAX_RES_TYPES ] =
{
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0
};


void resd_register( ResourceClass* rc )
{
    int i = rc->type;
    _resClass[ i ] = rc;
}


void resd_destroy( Resource* res )
{
    ResourceClass* rc;
    assert( res->resType < MAX_RES_TYPES );
    rc = _resClass[ res->resType ];
    assert( rc );
    if( rc->destroy )
        rc->destroy( res );
}


uint16_t resd_currentGroup()
{
    return _currentGroup;
}


/**
  Resources added with resd_add() will be assigned to the current group.
  The default group is zero.
*/
void resd_setCurrentGroup( uint16_t group )
{
    _currentGroup = group;
}


/*--------------------------------------------------------------------------*/


/**
  Allocates the memory for the hash table and prepares it for use.
  tableLen must be a power of 2.
*/
void resd_init( ResourceDict* dict, int tableLen )
{
    Resource** it;
    Resource** end;

    dict->table = memAlloc( sizeof(Resource*) * tableLen );
    assert( dict->table );
    dict->tableLen = tableLen;

    it  = dict->table;
    end = it + tableLen;
    while( it != end )
        *it++ = 0;
}


void resd_free( ResourceDict* dict )
{
    if( dict->table )
    {
        Resource* bi;
        Resource* next;
        Resource** it  = dict->table;
        Resource** end = it + dict->tableLen;

        while( it != end )
        {
            bi = *it;
            while( bi )
            {
                next = bi->resLink;
                resd_destroy( bi );
                bi = next;
            }

            ++it;
        }

        memFree( dict->table );
        dict->table    = 0;
        dict->tableLen = 0;
    }
}


/**
  Free all the resources in a dictionary which belong to a particular group.
*/
void resd_freeGroup( ResourceDict* dict, uint16_t group )
{
    if( dict->table )
    {
        Resource* bi;
        Resource* next;
        Resource* prev;
        Resource** it  = dict->table;
        Resource** end = it + dict->tableLen;

        while( it != end )
        {
            prev = 0;
            bi = *it;
            while( bi )
            {
                next = bi->resLink;
                if( bi->resGroup == group )
                {
                    if( prev )
                        prev->resLink = bi->resLink;
                    else
                        *it = bi->resLink;

                    resd_destroy( bi );
                }
                else
                {
                    prev = bi;
                }
                bi = next;
            }

            ++it;
        }
    }
}


uint32_t resd_hash( const char* buf, int len )
{
    // Justin Zobel's bitwise hash function.
    //  http://goanna.cs.rmit.edu.au/~hugh/zhw-ipl.html

    uint32_t hashval;
    const char* end = buf + len;

    hashval = 1159241;
    for( ; buf != end; ++buf )
        hashval ^= ((hashval << 5) + *buf + (hashval >> 2));

    return (hashval & 0x7fffffff);
}


/**
  Returns zero if not found.
*/
Resource* resd_lookup( const ResourceDict* dict, uint32_t key )
{
    Resource* it;
    Resource* prev = 0;
    Resource** table = dict->table + (key & (dict->tableLen - 1));

    for( it = *table; it; prev = it, it = it->resLink )
    {
        if( it->resKey == key )
        {
            if( prev )
            {
                // Move to front on access so commonly used words are
                // found more quickly.
                prev->resLink = it->resLink;
                it->resLink = *table;
                *table = it;
            }

            return it;
        }
    }
    return 0;
}


/**
  Add a Resource to the dictionary.
  A Resource can only be in a single dictionary.
*/
void resd_add( ResourceDict* dict, Resource* res, uint32_t key )
{
    Resource** table = dict->table + (key & (dict->tableLen - 1));
    res->resKey   = key;
    res->resLink  = *table;
    res->resGroup = _currentGroup;
    *table = res;
}


/**
  Returns pointer to Resource or zero if key is not found.
*/
Resource* resd_remove( ResourceDict* dict, uint32_t key )
{
    Resource* it;
    Resource* prev = 0;
    Resource** table = dict->table + (key & (dict->tableLen - 1));

    for( it = *table; it; prev = it, it = it->resLink )
    {
        if( it->resKey == key )
        {
            if( prev )
                prev->resLink = it->resLink;
            else
                *table = it->resLink;

            it->resLink = 0;
            return it;
        }
    }
    return 0;
}


/**
  Prints information about dictionary.
*/
void resd_statistics( ResourceDict* dict, const char* msg )
{
#ifndef NDEBUG
    int totalNodes = 0;
    int maxDepth = 0;
    int i;
    for( i = 0; i < dict->tableLen; ++i )
    {
        int count = 0;
        Resource* res = dict->table[ i ];
        while( res )
        {
            ++count;
            res = res->resLink;
        }

        if( count > maxDepth )
            maxDepth = count;
        totalNodes += count;
    }

    dprint( "%s [\n"
            "  table-size: %d\n"
            "  population: %d\n"
            "  average-depth: %d\n"
            "  maximum-depth: %d\n"
            "]\n",
            msg ? msg : "ResourceDict",
            dict->tableLen,
            totalNodes,
            totalNodes / dict->tableLen,
            maxDepth );
#endif
}


/*EOF*/