src/common/blist.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       blist.cpp, version 2.0                             *
************************************************************
*                                                          *
*the binary list idea. rewritten                           *
*                                                          *
*29'04'04- first revision; concepts based on o.05 branch's *
*blist.cpp. slight change: instead of saving pointers,     *
*blist copies the data into a new region of which it keeps *
*track. (2.0)                                              *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/memory/align.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/heap.hpp"
#include "src/common/blist.hpp"
#include "src/common/io.hpp"

//clear variables
void blist_t::init(uint32 fac) {
        head=NULL;tail=NULL;facility=fac;
        heap=&Memory::Heap::heap0;
        lock_blist.init(const_cast<char*>("blist"));
 }

//init
void blist_t::init (uint32 fac, Memory::Heap::heapbox *hp)
 {
        head=NULL;tail=NULL;facility=fac;
        heap=hp;
        lock_blist.init(const_cast<char*>("blist"));
 }

//init
void blist_t::init (const char *name, class Memory::Heap::heapbox *hp)
 {
        head=NULL;tail=NULL;facility=(uint32)name;      //is this QuickHack (tm)? this may cause any "facility managers"
//to implement checks whether it may be a string or a fac no.
        heap=hp;
        lock_blist.init((char*)name);
 }

//destroy all
void blist_t::done()
 {
        while (head) del(head);
        memset(this,0,sizeof(blist_t));
 }

//add a new object
blist_s *blist_t::add(void *data, size_t size, blist_t *tree)
 {
blist_s *new_obj;
void *copied_data;
//copy the data
        copied_data=heap->malloc(size,NO_ALIGN,FAC_BLIST|facility,NULL);
        if (copied_data==NULL)
                { complain("out of memory"); return NULL; }
        memmove(copied_data,data,size);
//allocate a book keeping object
        new_obj=(blist_s*) heap->malloc(sizeof(blist_s),NO_ALIGN,FAC_BLIST_BK|facility,NULL);
        if (new_obj == NULL)
                { complain("out of memory"); heap->free(copied_data); return NULL; }
//initialise data
        memset(new_obj,0,sizeof(blist_s));
        new_obj->tree=tree;
        new_obj->size=size;
        new_obj->data=copied_data;
//ziom, return the value
        return link(new_obj);
 }

/* find the data */
blist_s *blist_t::find(void *data)
 {
blist_s *item;
        for (item=head;item;item=item->next)
                if (item->data == data)
                        return item;

        return NULL;
 }

//delete an object
int blist_t::del(blist_s *obj)
 {
        lock_blist.lock();
//unlink from tha list
        if (obj->prev)
                obj->prev->next=obj->next;
        else
                head=obj->next;         //this was "head"

        if (obj->next)
                obj->next->prev=obj->prev;
        else
                tail=obj->prev;         //this was "tail"
//free memory
        if (obj->size != 0)     //if size is zero, then we should not free the object
                heap->free(obj->data);

        heap->free(obj);
        lock_blist.ulock();

        return ESUCCESS;
 }

//move an object to another list
blist_s *blist_t::move(blist_s *obj, blist_t *dest)
 {
//unlink from this list
        if (obj -> prev)
                obj -> prev -> next = obj -> next;
        else
                head = obj->next;

        if (obj->next)
                obj->next->prev = obj->prev;
        else
                tail=obj->prev;
//link to new
        return dest->link(obj);
 }

//link an object to the list
blist_s *blist_t::link(blist_s *obj)
 {
        lock_blist.lock();
//only object, ziom?
        if (head == NULL)
         {
                obj->prev=NULL;
                head=obj;
         } else 
          {
                tail->next=obj;
                obj->prev=tail;
          }
/*this is the last one*/
        obj->next=NULL;
        tail=obj;
        lock_blist.ulock();
//ziom, return the value
        return obj;
 }

//unlink
blist_s *blist_t::unlink(blist_s *obj)
 {
        if (obj->prev)
                obj->prev->next=obj->next;
        else
                head=obj->next;

        if (obj->next)
                obj->next->prev=obj->prev;
        else
                tail=obj->prev;
        obj->prev=NULL;obj->next=NULL;

        return obj;
 }

//add a pointer to an object
blist_s *blist_t::ptr(void *data, blist_t *tree)
 {
blist_s *new_obj;
//allocate a book keeping object
        new_obj=(blist_s*) heap->malloc(sizeof(blist_s),NO_ALIGN,FAC_BLIST_PTR|facility,NULL);
        if (new_obj == NULL)
                { complain("out of memory"); return NULL; }
//initialise data
        memset(new_obj,0,sizeof(blist_s));
        new_obj->tree=tree;
        new_obj->size=0;
        new_obj->data=data;
//ziom, return the value
        return link(new_obj);
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---