zeta/listimpl.h

   1 #define _LISTIMPL(X, Z)                 \
   2                                         \
   3 X##L*                                   \
   4 mk##X##L(Z hd, X##L *tl)                \
   5 {                                       \
   6         X##L *l;                        \
   7                                         \
   8         l = emallocnz(sizeof *l);               \
   9         l->hd = hd;                     \
  10         l->tl = tl;                     \
  11         return l;                       \
  12 }                                       \
  13                                         \
  14 X##L*                                   \
  15 copy##X##L(X##L *l)                     \
  16 {                                       \
  17         if(l == nil)                    \
  18                 return nil;             \
  19         return mk##X##L(l->hd, copy##X##L(l->tl));      \
  20 }                                       \
  21                                         \
  22 X##L*                                   \
  23 rev##X##L(X##L *l)                      \
  24 {                                       \
  25         X##L *next, *prev;              \
  26                                         \
  27         prev = nil;                     \
  28         for(; l; l=next){               \
  29                 next = l->tl;           \
  30                 l->tl = prev;           \
  31                 prev = l;               \
  32         }                               \
  33         return prev;                    \
  34 }                                       \
  35                                         \
  36 void                                    \
  37 free##X##L(X##L *l)                     \
  38 {                                       \
  39         if(l == nil)                    \
  40                 return;                 \
  41         free##X##L(l->tl);              \
  42         free(l);                        \
  43 }                                       \
  44                                         \
  45 int                                     \
  46 len##X##L(X##L *l)                      \
  47 {                                       \
  48         int i;                          \
  49                                         \
  50         i = 0;                          \
  51         for(; l; l=l->tl)               \
  52                 i++;                    \
  53         return i;                       \
  54 }                                       \
  55                                         \
  56 Z                                       \
  57 nth##X##L(X##L *l, int i)       \
  58 {                                       \
  59         while(i-- > 0)          \
  60                 l = l->tl;              \
  61         return l->hd;           \
  62 }                                       \
  63                                         \
  64 X##L*                           \
  65 add##X##L(X##L *l, X##L *ll) \
  66 {                                       \
  67         X##L *l1;                       \
  68         if(l == nil)                    \
  69                 return ll;              \
  70         if(ll == nil)                   \
  71                 return l;               \
  72         l1 = l;                 \
  73         while(l1->tl)           \
  74                 l1 = l1->tl;    \
  75         l1->tl = ll;                    \
  76         return l;                       \
  77 }                                       \
  78                                         \
  79 X##L*                           \
  80 sort##X##L(X##L *l, int (*cmp)(typeof(((X##L*)0)->hd), typeof(((X##L*)0)->hd))) \
  81 {                                       \
  82         assert(sizeof(l->hd) == sizeof(void*)); \
  83         return (X##L*)listsort((PtrL*)l, (int(*)(void*, void*))cmp); \
  84 }                                       \
  85                                         \
  86 X##L*                           \
  87 uniq##X##L(X##L *l)     \
  88 {                                       \
  89         X##L *l1;                       \
  90         l1 = l;                 \
  91         while(l){                       \
  92                 while(l->tl && l->hd == l->tl->hd) \
  93                         l->tl = l->tl->tl; \
  94                 l = l->tl;              \
  95         }                               \
  96         return l1;                      \
  97 }                                       \
  98
  99 #define LISTIMPL(X) _LISTIMPL(X, X*)