Introduce a statusline buffer.

A buffer is introduced for the statusline which will only be copied to the actual statusline
once an entire statusline is parsed. This avoids a race condition where incompletely parsed
statuslines were rendered, causing only some status blocks to be rendered which is visible to
the user as a flickering.

fixes #1480

i3bar/src/child.c

@@ -54,25 +54,40 @@ typedef struct parser_ctx {
 
 parser_ctx parser_context;
 
-/* The buffer statusline points to */
 struct statusline_head statusline_head = TAILQ_HEAD_INITIALIZER(statusline_head);
+/* Used temporarily while reading a statusline */
+struct statusline_head statusline_buffer = TAILQ_HEAD_INITIALIZER(statusline_buffer);
 
 int child_stdin;
 
 /*
- * Clears all blocks from the statusline structure in memory and frees their
+ * Remove all blocks from the given statusline.
- * associated resources.
+ * If free_resources is set, the fields of each status block will be free'd.
  */
-static void clear_status_blocks() {
+static void clear_statusline(struct statusline_head *head, bool free_resources) {
     struct status_block *first;
-    while (!TAILQ_EMPTY(&statusline_head)) {
+    while (!TAILQ_EMPTY(head)) {
-        first = TAILQ_FIRST(&statusline_head);
+        first = TAILQ_FIRST(head);
-        I3STRING_FREE(first->full_text);
+        if (free_resources) {
-        TAILQ_REMOVE(&statusline_head, first, blocks);
+            I3STRING_FREE(first->full_text);
+            FREE(first->color);
+            FREE(first->name);
+        }
+
+        TAILQ_REMOVE(head, first, blocks);
         free(first);
     }
 }
 
+static void copy_statusline(struct statusline_head *from, struct statusline_head *to) {
+    struct status_block *current;
+    TAILQ_FOREACH (current, from, blocks) {
+        struct status_block *new_block = smalloc(sizeof(struct status_block));
+        memcpy(new_block, current, sizeof(struct status_block));
+        TAILQ_INSERT_TAIL(to, new_block, blocks);
+    }
+}
+
 /*
  * Replaces the statusline in memory with an error message. Pass a format
  * string and format parameters as you would in `printf'. The next time
@@ -80,7 +95,7 @@ static void clear_status_blocks() {
  * the space allocated for the statusline.
  */
 __attribute__((format(printf, 1, 2))) static void set_statusline_error(const char *format, ...) {
-    clear_status_blocks();
+    clear_statusline(&statusline_head, true);
 
     char *message;
     va_list args;
@@ -126,20 +141,12 @@ void cleanup(void) {
 
 /*
  * The start of a new array is the start of a new status line, so we clear all
- * previous entries.
+ * previous entries from the buffer.
- *
  */
 static int stdin_start_array(void *context) {
-    struct status_block *first;
+    // the blocks are still used by statusline_head, so we won't free the
-    while (!TAILQ_EMPTY(&statusline_head)) {
+    // resources here.
-        first = TAILQ_FIRST(&statusline_head);
+    clear_statusline(&statusline_buffer, false);
-        I3STRING_FREE(first->full_text);
-        FREE(first->color);
-        FREE(first->name);
-        FREE(first->instance);
-        TAILQ_REMOVE(&statusline_head, first, blocks);
-        free(first);
-    }
     return 1;
 }
 
@@ -222,6 +229,10 @@ static int stdin_integer(void *context, long long val) {
     return 1;
 }
 
+/*
+ * When a map is finished, we have an entire status block.
+ * Move it from the parser's context to the statusline buffer.
+ */
 static int stdin_end_map(void *context) {
     parser_ctx *ctx = context;
     struct status_block *new_block = smalloc(sizeof(struct status_block));
@@ -232,11 +243,19 @@ static int stdin_end_map(void *context) {
         new_block->full_text = i3string_from_utf8("SPEC VIOLATION: full_text is NULL!");
     if (new_block->urgent)
         ctx->has_urgent = true;
-    TAILQ_INSERT_TAIL(&statusline_head, new_block, blocks);
+    TAILQ_INSERT_TAIL(&statusline_buffer, new_block, blocks);
     return 1;
 }
 
+/*
+ * When an array is finished, we have an entire statusline.
+ * Copy it from the buffer to the actual statusline.
+ */
 static int stdin_end_array(void *context) {
+    DLOG("copying statusline_buffer to statusline_head\n");
+    clear_statusline(&statusline_head, true);
+    copy_statusline(&statusline_buffer, &statusline_head);
+
     DLOG("dumping statusline:\n");
     struct status_block *current;
     TAILQ_FOREACH(current, &statusline_head, blocks) {