libs/basekit/source/Stack_inline.h

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