libs/basekit/source/Stack_inline.h

   1 //metadoc Stack copyright Steve Dekorte 2002
   2 //metadoc Stack license BSD revised
   3 /*metadoc Stack description
   4  Stack - array of void pointers
   5  supports setting marks - when a mark is popped,
   6  all stack items above it are popped as well
   7  */
   8
   9 #ifdef STACK_C
  10 #define IO_IN_C_FILE
  11 #endif
  12 #include "Common_inline.h"
  13 #ifdef IO_DECLARE_INLINES
  14
  15 IOINLINE void Stack_do_(const Stack *self, StackDoCallback *callback)
  16 {
  17         void **itemP = self->top;
  18         intptr_t mark = self->lastMark;
  19
  20         while (itemP > self->items)
  21         {
  22                 if (itemP - self->items == mark)
  23                 {
  24                         mark = (intptr_t)(*itemP);
  25                 }
  26                 else
  27                 {
  28                         (*callback)(*itemP);
  29                 }
  30
  31                 itemP --;
  32         }
  33 }
  34
  35 IOINLINE void Stack_doUntilMark_(const Stack *self, StackDoCallback *callback)
  36 {
  37         void **itemP = self->top;
  38         intptr_t mark = self->lastMark;
  39
  40         while (itemP > self->items)
  41         {
  42                 if (itemP - self->items == mark)
  43                 {
  44                         return;
  45                 }
  46                 else
  47                 {
  48                         (*callback)(*itemP);
  49                 }
  50
  51                 itemP --;
  52         }
  53 }
  54
  55 IOINLINE void Stack_clear(Stack *self)
  56 {
  57         self->top = self->items;
  58         self->lastMark = 0;
  59 }
  60
  61 IOINLINE size_t Stack_totalSize(const Stack *self)
  62 {
  63         return (self->top - self->items);
  64 }
  65
  66 IOINLINE int Stack_count(const Stack *self)
  67 {
  68         return (self->top - self->items);
  69 }
  70
  71 IOINLINE void Stack_push_(Stack *self, void *item)
  72 {
  73         self->top ++;
  74
  75         if (self->top == self->memEnd)
  76         {
  77                 Stack_resize(self);
  78         }
  79
  80         *(self->top) = item;
  81 }
  82
  83 IOINLINE void Stack_pushMark(Stack *self)
  84 {
  85         Stack_push_(self, (void *)self->lastMark);
  86         self->lastMark = self->top - self->items;
  87 }
  88
  89 IOINLINE intptr_t Stack_pushMarkPoint(Stack *self)
  90 {
  91         Stack_push_(self, (void *)self->lastMark);
  92         self->lastMark = self->top - self->items;
  93         return self->lastMark;
  94 }
  95
  96 IOINLINE void *Stack_pop(Stack *self)
  97 {
  98         void *top = *(self->top);
  99
 100         if (self->items != self->top)
 101         {
 102 #ifdef STACK_POP_CALLBACK
 103                 if(self->popCallback) self->popCallback(*(self->top));
 104 #endif
 105                 self->top --;
 106         }
 107
 108         return top;
 109 }
 110
 111 IOINLINE void Stack_popMark(Stack *self)
 112 {
 113 #ifdef STACK_POP_CALLBACK
 114         if(self->popCallback) Stack_doUntilMark_(self, self->popCallback);
 115 #endif
 116
 117         self->top = self->items + self->lastMark - 1;
 118
 119         if (self->lastMark)
 120         {
 121                 self->lastMark = (intptr_t)(self->items[self->lastMark]);
 122         }
 123 }
 124
 125 IOINLINE int Stack_popMarkPoint_(Stack *self, intptr_t mark)
 126 {
 127         while (self->lastMark && self->lastMark != mark)
 128         {
 129                 Stack_popMark(self);
 130         }
 131
 132         if (self->lastMark != mark)
 133         {
 134                 return 0;
 135         }
 136
 137         Stack_popMark(self);
 138         return 1;
 139 }
 140
 141 IOINLINE void Stack_clearTop(Stack *self)
 142 {
 143         Stack_popMark(self);
 144         Stack_pushMark(self);
 145         //self->top = self->items + self->lastMark;
 146 }
 147
 148 IOINLINE void *Stack_top(const Stack *self)
 149 {
 150         return *(self->top);
 151 }
 152
 153 IOINLINE void *Stack_at_(const Stack *self, int i)
 154 {
 155         return self->items[i + 1];
 156 }
 157
 158
 159
 160 #undef IO_IN_C_FILE
 161 #endif
 162