From: Michael D. Lowis <mike@mdlowis.com>
Date: Sun, 29 Mar 2020 02:41:25 +0000 (-0400)
Subject: add common list routines
X-Git-Url: https://git.mdlowis.com/?a=commitdiff_plain;h=69d3fca971c832c70cffa7acf37e0e7ee178d8b6;p=proto%2Fanvil.git

add common list routines
---

diff --git a/anvil.h b/anvil.h
index c485a57..79a9481 100644
--- a/anvil.h
+++ b/anvil.h
@@ -52,6 +52,10 @@ enum {
     F_SHADED    = (1 << 2),
 };
 
+typedef struct Node {
+    struct Node* next;
+} Node;
+
 typedef struct Client {
     struct Client* next;
     char* name;
@@ -109,6 +113,17 @@ typedef struct {
 /* anvil.c */
 extern XConf X;
 
+/* list.c */
+//void* list_add(void* list, void* node);
+int list_length(void* list);
+void* list_del(void* list, void* node);
+void* list_prev(void* list, void* curr);
+void* list_last(void* list);
+#define LIST_FOR_EACH(val,list) \
+    for (val = list; (val != NULL); val = val->next)
+#define LIST_FOR_EACH_UNTIL(val,list,cond) \
+    for (val = list; (val != NULL) && !(cond); val = val->next)
+
 /* keys.c */
 void keys_init(void);
 void keys_run(XKeyEvent* ev);
@@ -174,5 +189,4 @@ void xfree(void* p);
 Atom atom(char* str);
 void sendmsg(Window win, Atom proto, Atom type);
 void warp_mouse(Client* c);
-Client* delclient(Client* list, Client* dead);
 void get_mouse(int* ptrx, int* ptry);
diff --git a/list.c b/list.c
new file mode 100644
index 0000000..d975505
--- /dev/null
+++ b/list.c
@@ -0,0 +1,41 @@
+#include "anvil.h"
+
+int list_length(void* list)
+{
+    int length = 0;
+    for (Node* n = list; n; n = n->next, length++);
+    return length;
+}
+
+void* list_del(void* list, void* node)
+{
+    Node *l = list, *n = node;
+    if (!l)
+    {
+        return NULL;
+    }
+    else if (l == n)
+    {
+        return l->next;
+    }
+    else
+    {
+        l->next = list_del(l->next, n);
+        return l;
+    }
+}
+
+void* list_prev(void* list, void* node)
+{
+    Node *prev = list, *n = node;
+    for (; prev->next != n; prev = prev->next);
+    return prev;
+}
+
+void* list_last(void* list)
+{
+    Node* tail = list;
+    for (; tail && tail->next; tail = tail->next);
+    return tail;
+}
+
diff --git a/mons.c b/mons.c
index 00926d1..14d3bf2 100644
--- a/mons.c
+++ b/mons.c
@@ -52,13 +52,15 @@ void mons_layer(Monitor* mon)
 {
     int nwins = 0;
     Window* wins = NULL;
-    for (Client* c = mon->cspace->floating; c; c = c->next)
+    Client* c;
+    Column* col;
+    LIST_FOR_EACH(c, mon->cspace->floating)
     {
         wins = realloc(wins, ++nwins * sizeof(Window));
         wins[nwins-1] = c->frame;
     }
     /* add in the monocled windows first */
-    for (Column* col = mon->cspace->columns; col; col = col->next)
+    LIST_FOR_EACH(col, mon->cspace->columns)
     {
         if (col->focused)
         {
@@ -67,9 +69,9 @@ void mons_layer(Monitor* mon)
         }
     }
     /* now lower all of the tiled windows */
-    for (Column* col = mon->cspace->columns; col; col = col->next)
+    LIST_FOR_EACH(col, mon->cspace->columns)
     {
-        for (Client* c = col->clients; c; c = c->next)
+        LIST_FOR_EACH(c, col->clients)
         {
             if (col->focused != c)
             {
@@ -108,15 +110,17 @@ void mons_delclient(Client* c)
 
 int mons_find(Window win, Location* loc)
 {
-    for (Monitor* mon = Monitors; mon; mon = mon->next)
+    Monitor* mon;
+    Workspace* wspace;
+    LIST_FOR_EACH(mon, Monitors)
     {
-        for (Workspace* wspace = mon->wspaces; wspace; wspace = wspace->next)
+        LIST_FOR_EACH(wspace, mon->wspaces)
         {
             Column* column = NULL;
             Client* client = client_find(wspace->floating, win);
             if (!client)
             {
-                for (column = wspace->columns; column; column = column->next)
+                LIST_FOR_EACH(column, wspace->columns)
                 {
                     if ( (client = client_find(column->clients, win)) )
                     {
@@ -149,8 +153,8 @@ void mons_place(Client* c)
     if (mons_find(c->win, &loc) && !loc.column)
     {
         int maxarea = 0;
-        Monitor* closest = NULL;
-        for (Monitor* mon = Monitors; mon; mon = mon->next)
+        Monitor *mon = NULL, *closest = NULL;
+        LIST_FOR_EACH(mon, Monitors)
         {
             int left = max(cleft, mon->x);
             int right = min(cright, mon->x + mon->w);
@@ -169,7 +173,7 @@ void mons_place(Client* c)
         /* if we changed monitors, make sure we update accordingly */
         if (closest && loc.monitor != closest)
         {
-            loc.workspace->floating = delclient(loc.workspace->floating, c);
+            loc.workspace->floating = list_del(loc.workspace->floating, c);
             c->next = closest->cspace->floating;
             closest->cspace->floating = c;
         }
@@ -209,7 +213,7 @@ void mons_towspace(Client* c, int wsid)
 
 void mons_raise(Monitor* mon, Client* c)
 {
-    mon->cspace->floating = delclient(mon->cspace->floating, c);
+    mon->cspace->floating = list_del(mon->cspace->floating, c);
     c->next = mon->cspace->floating;
     mon->cspace->floating = c;
     mons_layer(mon);
@@ -217,12 +221,11 @@ void mons_raise(Monitor* mon, Client* c)
 
 void mons_lower(Monitor* mon, Client* c)
 {
-    mon->cspace->floating = delclient(mon->cspace->floating, c);
+    mon->cspace->floating = list_del(mon->cspace->floating, c);
     c->next = NULL;
     if (mon->cspace->floating)
     {
-        Client* curr = mon->cspace->floating;
-        for (; curr && curr->next; curr = curr->next);
+        Client* curr = list_last(mon->cspace->floating);
         curr->next = c;
     }
     else
@@ -333,23 +336,20 @@ void mons_tilemove(Location* loc, int hdiff)
 static Monitor* pickmon(void)
 {
     get_mouse(&PtrX, &PtrY);
-    Monitor* mon = Monitors;
-    for (; mon; mon = mon->next)
-    {
-        if ((mon->x <= PtrX && PtrX < mon->x+mon->w) && (mon->y <= PtrY && PtrY < mon->y+mon->h))
-        {
-            break;
-        }
-    }
+    Monitor* mon;
+    LIST_FOR_EACH_UNTIL(mon, Monitors,
+        (mon->x <= PtrX && PtrX < mon->x+mon->w) &&
+        (mon->y <= PtrY && PtrY < mon->y+mon->h)
+    );
     mon = (mon ? mon : Monitors);
     return mon;
 }
 
 static Column* pickcol(Column* cols, int relx)
 {
-    Column* col = cols;
+    Column* col;
     int left = 0, right = 0;
-    for (col = cols; col; col = col->next)
+    LIST_FOR_EACH(col, cols)
     {
         left = right, right += col->width;
         if (left <= relx && relx < right)
@@ -362,27 +362,23 @@ static Column* pickcol(Column* cols, int relx)
 
 static Workspace* pickws(Monitor* mon, int wsid)
 {
-    Workspace* wspace = mon->wspaces;
+    Workspace* wspace;
     int i = 0;
-    for (; wspace; wspace = wspace->next, i++)
-    {
-        if (i == wsid)
-        {
-            break;
-        }
-    }
+    LIST_FOR_EACH_UNTIL(wspace, mon->wspaces, (i++ == wsid));
     return wspace;
 }
 
 static void client_visibility(Workspace* wspace, int show)
 {
-    for (Client* client = wspace->floating; client; client = client->next)
+    Column* col;
+    Client* client;
+    LIST_FOR_EACH(client, wspace->floating)
     {
         client_show(client, show);
     }
-    for (Column* col = wspace->columns; col; col = col->next)
+    LIST_FOR_EACH(col, wspace->columns)
     {
-        for (Client* client = col->clients; client; client = client->next)
+        LIST_FOR_EACH(client, col->clients)
         {
             client_show(client, show);
         }
@@ -392,14 +388,9 @@ static void client_visibility(Workspace* wspace, int show)
 
 static Client* client_find(Client* clients, Window win)
 {
-    Client* client = clients;
-    for (; client; client = client->next)
-    {
-        if (client->frame == win || client->win == win)
-        {
-            break;
-        }
-    }
+    Client* client;
+    LIST_FOR_EACH_UNTIL(client, clients,
+        (client->frame == win || client->win == win));
     return client;
 }
 
@@ -415,9 +406,8 @@ static void add_client(Monitor* mon, Client* c, int ptrx)
     }
     else
     {
-        Column* col = mon->cspace->columns;
         /* find first empty column, and fill that first */
-        for (; col && col->clients; col = col->next);
+        Column* col = list_last(mon->cspace->columns);
         if (!col)
         {
             /* otherwise pick the column to the right or current column */
@@ -445,7 +435,7 @@ static void remove_client(Location* loc, Client* c)
 {
     if (!loc->column)
     {
-        loc->workspace->floating = delclient(loc->workspace->floating, c);
+        loc->workspace->floating = list_del(loc->workspace->floating, c);
     }
     else if (loc->column->focused)
     {
@@ -459,7 +449,8 @@ static void remove_client(Location* loc, Client* c)
 
 static void adjust_all(Column* col, int xoff)
 {
-    for (Client* c = col->clients; c; c = c->next)
+    Client* c;
+    LIST_FOR_EACH(c, col->clients)
     {
         c->x += xoff;
         c->w = col->width;
diff --git a/mouse.c b/mouse.c
index c781af3..7a6a294 100644
--- a/mouse.c
+++ b/mouse.c
@@ -49,7 +49,7 @@ static void monocled_click(XButtonEvent* ev, Location* loc)
         if (client->next)
         {
             loc->column->clients = client->next;
-            for (tail = loc->column->clients; tail && tail->next; tail = tail->next);
+            tail = list_last(loc->column->clients);
             client->next = NULL;
             tail->next = client;
             monocled_set(loc->monitor, loc->column, loc->column->clients);
diff --git a/tile.c b/tile.c
index 7b693dc..72b4bfc 100644
--- a/tile.c
+++ b/tile.c
@@ -2,8 +2,12 @@
 
 static void coldims(Monitor* mon, Column* col, int *x, int *y, int *w, int *h)
 {
+    Column* c;
     *x = mon->x, *y = mon->y, *w = col->width-2, *h = mon->h-2;
-    for (Column* c = mon->cspace->columns; c != col; *x += c->width, c = c->next);
+    LIST_FOR_EACH_UNTIL(c, mon->cspace->columns, (c == col))
+    {
+        *x += c->width;
+    }
 }
 
 void monocled_add(Monitor* mon, Column* col, Client* c)
@@ -17,7 +21,7 @@ void monocled_add(Monitor* mon, Column* col, Client* c)
 
 void monocled_del(Monitor* mon, Column* col, Client* c)
 {
-    col->clients = delclient(col->clients, c);
+    col->clients = list_del(col->clients, c);
     col->focused = col->clients;
     c = col->clients;
     if (c)
@@ -29,7 +33,7 @@ void monocled_del(Monitor* mon, Column* col, Client* c)
 
 void monocled_set(Monitor* mon, Column* col, Client* c)
 {
-    col->clients = delclient(col->clients, c);
+    col->clients = list_del(col->clients, c);
     c->next = col->clients;
     col->clients = c;
     col->focused = c;
@@ -44,12 +48,12 @@ void stacked_add(Monitor* mon, Column* col, Client* c)
     coldims(mon, col, &(c->x), &(c->y), &(c->w), &(c->h));
     if (col->clients)
     {
-        Client* max = col->clients;
-        for (Client* c = max; c; c = c->next)
+        Client *cl, *max = col->clients;
+        LIST_FOR_EACH(cl, max)
         {
-            if (c->h > max->h)
+            if (cl->h > max->h)
             {
-                max = c;
+                max = cl;
             }
         }
         if (max->h < 3*MIN_HEIGHT)
@@ -101,8 +105,7 @@ void stacked_del(Monitor* mon, Column* col, Client* c)
     }
     else
     {
-        Client* prev = col->clients;
-        for (; prev->next != c; prev = prev->next);
+        Client* prev = list_prev(col->clients, c);
         prev->next = c->next;
         prev->h += c->h;
         client_setshade(prev, 0);
@@ -114,12 +117,11 @@ void stacked_set(Monitor* mon, Column* col, Client* c)
 {
     (void)c;
     col->focused = NULL;
-    int nclients = 0;
-    for (Client* c = col->clients->next; c; c = c->next, nclients++);
+    int nclients = list_length(col->clients->next);
     int starty = (mon->y + mon->h) - (nclients * MIN_HEIGHT);
     col->clients->h = starty - mon->y - 1;
     client_adjust(col->clients);
-    for (Client* c = col->clients->next; c; c = c->next)
+    LIST_FOR_EACH(c, col->clients->next)
     {
         c->y = starty;
         c->h = MIN_HEIGHT;
@@ -131,8 +133,7 @@ void stacked_set(Monitor* mon, Column* col, Client* c)
 
 void stacked_addheight(Monitor* mon, Column* col, Client* c, int amount)
 {
-    Client* prev = col->clients;
-    for (; prev && prev->next != c; prev = prev->next);
+    Client* prev = list_prev(col->clients, c);
     if (prev)
     {
         amount = (abs(amount) < BORDER_WIDTH ? min((int)(-c->h * 0.25), -2*MIN_HEIGHT) : amount);
@@ -141,7 +142,7 @@ void stacked_addheight(Monitor* mon, Column* col, Client* c, int amount)
         c->y = max(miny, min(maxy, c->y + amount));
         prev->h = c->y - prev->y;
         c->h = (c->next ? c->next->y : mon->y + mon->h) - c->y;
-        printf("ADD_HEIGHT1(w: %lx x: %d y: %d w: %d h: %d)\n", c->frame, c->x, c->y, c->w, c->h);
+        printf("ADD_HEIGHT(w: %lx x: %d y: %d w: %d h: %d)\n", c->frame, c->x, c->y, c->w, c->h);
         client_setshade(prev, (prev->h <= MIN_HEIGHT));
         client_setshade(c, (c->h <= MIN_HEIGHT));
         client_adjust(prev);
diff --git a/util.c b/util.c
index bfe1343..08c6989 100644
--- a/util.c
+++ b/util.c
@@ -60,23 +60,6 @@ void warp_mouse(Client* c)
     X.last_y = c->y + new_h;
 }
 
-Client* delclient(Client* list, Client* dead)
-{
-    if (!list)
-    {
-        return NULL;
-    }
-    else if (list == dead)
-    {
-        return list->next;
-    }
-    else
-    {
-        list->next = delclient(list->next, dead);
-        return list;
-    }
-}
-
 void get_mouse(int* ptrx, int* ptry)
 {
     Window root = 0, child = 0;