src/common/stack.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                             *
************************************************************
*       stack.cpp, version 1.1                             *
************************************************************
*                                                          *
*generic stack functions if you need it, as in page        *
*allocation.                                               *
*                                                          *
*23'04'04- form from 0.05 branch (1.1)                     *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/memory/memset.hpp"
#include "src/common/stack.hpp"
#include "src/common/kmalloc.hpp"

const uint32 DEF_ERROR = 0xffffffff;
// /*init for longwords*/
// stack_t::stack_t()
//  {
//  }
// 
// /*init with for min_elems elems*/
// stack_t::stack_t(uint32 min_elems)
//  {
// /*----*/
//  }
// 
// /*init with a buffer and it's size*/
// stack_t::stack_t(char *buffer, uint32 elems)
//  {
// /*init*/
//      nw(buffer, elems);
//  }

void stack_t::nw(char *buffer, uint32 elems)
 {
/*set variables*/
        stack = (uint32*) buffer; max_elems = elems;
        stack_ptr = 0;
   expandable=0;
 }

void stack_t::setExpandable() {
   expandable=0xbabef00l;
}

// /*done. dispose all memory*/
// stack_t::~stack_t()
//  {
//  }

void stack_t::inval()
 {
/*zero all variables*/
        stack = NULL; max_elems = 0;
        stack_ptr = 0;
 }

void stack_t::verify()
 {
uint32 *new_buf;
/*check, if there's a buffer*/
        if (stack == NULL) {
      if (expandable != 0xbabef00l) {
         sysfail("blad");
      }
                nw(static_cast<char*>(kmalloc(0x1000, "stack buffer")), 0x400); /*create a 4096-byte stack*/
   }
/*check*/
        if ( stack_ptr + 1 > max_elems )
                {
      if (expandable != 0xbabef00l) {
         debug_dump_call_trace();
         sysfail("blad;");
      }
                /*allocate more memory*/
                        new_buf = (uint32*) kmalloc((max_elems+0x400)*4,"stackbuf");
                        memmove(new_buf,stack, max_elems*4);
                /*sanity check*/
                        if (!new_buf)
                                sysfail("krealloc failed");
                /*release old buffer, save new*/
                        kfree(stack);
                        stack = new_buf;
                        max_elems+=0x400;
                }
 }

/*push a longword. returns position in stack*/
uint32 stack_t::push(uint32 data)
 {
/*check space*/
        verify();

/*push value*/
        stack[stack_ptr] = data;
/*return the data's #*/
        return stack_ptr++;
 }

/*pop a longword. returns value*/
uint32 stack_t::pop()
 {
/*decrease ptr*/
        stack_ptr --;
/*return value*/
        return stack[stack_ptr];
 }

/*find if _val is on the stack, then pop it. return DEF_ERROR if not found or position in stack of the element (0- the most bottom element)*/
uint32 stack_t::pop_value(uint32 val)
{
   uint32 i, flag = 0;
   /*find the element*/
   for (i=0; i<stack_ptr; i++)
      if (stack[i] == val)
      {flag=1; break;}
   /*return if not found*/
   if (!flag)
      return DEF_ERROR;
   /*now pop the value, by moving the rest of elements 4 bytes down*/
   memmove(i*4 + (char*)stack,  /*dest: the place where _val was situated*/
         4 + i*4 + (char*)stack,        /*source: the first element above the _val*/
         (stack_ptr - i - 1)*4);        /*count: element count above _val, each element 4 bytes*/
   /*one less element*/
   stack_ptr--;
   /*return position*/
   return i;
}

/*adds the value to the bottom of the stack*/
uint32 stack_t::push_top(uint32 val)
 {
        verify();       /*check the buffer is big enough*/

        memmove((char*) stack + 4,stack, stack_ptr * 4);        /*move the stack upwards in memory*/

        stack[0] = val;
        stack_ptr++;

        return 0;
 }

/*find position of _val or return -1 when not found*/
uint32 stack_t::find(uint32 val)
 {
uint32 i, flag = 0;
/*find the element*/
        for (i=0; i<stack_ptr; i++)
                if (stack[i] == val)
                 {flag=1; break;}
/*return if not found*/
        if (!flag)
                return DEF_ERROR;

        return i;
 }

/*returns the element count on stack*/
uint32 stack_t::lgth()
 {
/*lgth == stack_ptr*/
        return stack_ptr;
 }

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

---