common/list.c

   1 /* list.c
   2         functions for static list implimentation.
   3 */
   4 #include <stdio.h>
   5 #include <stdint.h>
   6 #include <stdbool.h>
   7
   8 #include "list.h"
   9
  10 #define likely(x)       __builtin_expect((x),1)
  11 #define unlikely(x)     __builtin_expect((x),0)
  12
  13 #define LIST_ERROR(...) fprintf(stderr,"ERROR: %s:%s():%d \n",__FILE__,__FUNCTION__,__LINE__);
  14
  15
  16 list_base_t list_pop_front(list_t *l) {
  17         if ( unlikely( list_empty(l) ) ) {
  18                 LIST_ERROR();
  19                 return 0;
  20         }
  21
  22         list_base_t head = l->buffer[ l->first ];
  23
  24         l->first++;
  25         if ( l->first >= l->sz )
  26                 l->first = 0;
  27
  28         --(l->ct);
  29
  30         return head;
  31 }
  32
  33 list_base_t list_pop_back(list_t *l) {
  34         if ( unlikely( list_empty(l) ) ) {
  35                 LIST_ERROR();
  36                 return 0;
  37         }
  38
  39         l->ct--;
  40
  41         l->end--;
  42         if ( l->end >= l->sz) // if overflowed
  43                 l->end = l->sz - 1;
  44
  45         list_base_t last = l->buffer[l->end];
  46
  47         return last;
  48 }
  49
  50 list_error_t list_push_front(list_t *l, list_base_t x) {
  51         if ( unlikely( list_full(l) ) ){
  52                 LIST_ERROR();
  53                 return -1;
  54         }
  55
  56         l->ct++;
  57
  58         l->first--;
  59         if ( l->first >= l->sz ) // if overflowed
  60                 l->first = l->sz - 1;
  61
  62         l->buffer[ l->first ] = x;
  63
  64         return 0;
  65 }
  66
  67 list_error_t list_push_back(list_t *l, list_base_t x) {
  68         if ( unlikely( list_full(l) ) ){
  69                 LIST_ERROR();
  70                 return -1;
  71         }
  72
  73         l->ct++;
  74
  75         l->buffer[ l->end ] = x;
  76
  77         l->end++;
  78         if ( l->end >= l->sz )
  79                 l->end = 0;
  80
  81         return 0;
  82 }
  83
  84 list_error_t list_push_back_o(list_t *l, list_base_t x) {
  85         l->buffer[ l->end ] = x;
  86
  87         l->end++;
  88         if ( l->end >= l->sz )
  89                 l->end = 0;
  90
  91         if (!list_full(l))
  92                 ++(l->ct);
  93
  94         return 0;
  95 }
  96
  97 list_base_t list_peek_front(list_t *l) {
  98         if ( unlikely( list_empty(l) ) ) {
  99                 LIST_ERROR();
 100                 return 0;
 101         }
 102
 103         return l->buffer[l->first];
 104 }
 105 list_base_t list_peek_back(list_t *l) {
 106         if ( unlikely( list_empty(l) ) ) {
 107                 LIST_ERROR();
 108                 return 0;
 109         }
 110
 111         list_index_t last = l->end-1;
 112         if (last >= l->sz) {
 113                 last = l->sz-1;
 114         }
 115
 116         return l->buffer[last];
 117 }
 118
 119
 120
 121 list_base_t list_peek(list_t *l, list_index_t index) {
 122         if ( unlikely( index > l->ct ) ) {
 123                 LIST_ERROR();
 124                 return 0;
 125         }
 126
 127         uint8_t sum = l->first + index;
 128         uint8_t diff = l->first - index;
 129
 130         if ( sum < l->first ) {
 131                 //XXX: damn overflow.
 132         }
 133
 134         if ( sum >= l->sz ) {
 135
 136         }
 137 }
 138
 139 void list_flush(list_t *list) {
 140         list->first = list->end;
 141         list->ct = 0;
 142 }
 143
 144 bool list_empty(list_t *list) {
 145         if ( unlikely( list->ct == 0 ) )        return true;
 146         else            return false;
 147 }
 148
 149 bool list_full(list_t *list) {
 150         if ( unlikely( list->ct >= list->sz ) ) return true;
 151         else                    return false;
 152 }