text: #include "callstack.h"
  #include "debug.h"
  #include "mem.h"
  #include "timing.h"
  #include "config.h"
  
  int
  slen(_cstack *cs)
  {
      return 1 + cs->head;
  }
  
  _cstack *
  screate(int size)
  {
      int i;
      _cstack *cs;
  
      cs = (_cstack *)ymalloc(sizeof(_cstack));
      if (!cs)
          return NULL;
      cs->_items = ymalloc(size * sizeof(_cstackitem));
      if (cs->_items == NULL) {
          yfree(cs);
          return NULL;
      }
      
      for(i=0; i<size; i++) {
          cs->_items[i].ckey = 0;
          cs->_items[i].t0 = 0;
      }
  
      cs->size = size;
      cs->head = -1;
      return cs;
  }
  
  static int
  _sgrow(_cstack * cs)
  {
      int i;
      _cstack *dummy;
  
      dummy = screate(cs->size*2);
      if(!dummy)
          return 0;
  
      for(i=0; i<cs->size; i++) {
          dummy->_items[i].ckey = cs->_items[i].ckey;
          dummy->_items[i].t0 = cs->_items[i].t0;
      }
      yfree(cs->_items);
      cs->_items = dummy->_items;
      cs->size = dummy->size;    
      yfree(dummy);
      return 1;
  }
  
  void
  sdestroy(_cstack * cs)
  {
      yfree(cs->_items);
      yfree(cs);
  }
  
  
  _cstackitem *
  spush(_cstack *cs, void *ckey)
  {
      _cstackitem *ci;
  
      if (cs->head >= cs->size-1) {
          if (!_sgrow(cs))
              return NULL;
      }
  
      ci = &cs->_items[++cs->head];
      ci->ckey = ckey;
  
      return ci;
  }
  
  _cstackitem *
  spop(_cstack * cs)
  {
      _cstackitem *ci;
  
      if (cs->head < 0)
          return NULL;
  
      ci = &cs->_items[cs->head--];
      return ci;
  }
  
  _cstackitem *
  shead(_cstack * cs)
  {
      if (cs->head < 0)
          return NULL;
  
      return &cs->_items[cs->head];
  }
  