From ed7c855166a7b3d8ba217c60acd81f9f720a8ef1 Mon Sep 17 00:00:00 2001
From: "Michael D. Lowis" <mike.lowis@gentex.com>
Date: Mon, 30 Sep 2019 12:52:26 -0400
Subject: [PATCH] finish converting brace styling

---
 src/lib/buf.c | 533 ++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 413 insertions(+), 120 deletions(-)

diff --git a/src/lib/buf.c b/src/lib/buf.c
index 98a84bb..c8841f2 100644
--- a/src/lib/buf.c
+++ b/src/lib/buf.c
@@ -143,6 +143,7 @@ static void putch(Buf* buf, char b, Sel* p_sel)
     {
         return;
     }
+
     if (b == '\n' && DosLineFeed)
     {
         putb(buf, '\r', p_sel);
@@ -154,9 +155,13 @@ static void putch(Buf* buf, char b, Sel* p_sel)
     }
 }
 
-void buf_init(Buf* buf) {
+void buf_init(Buf* buf)
+{
+    require(buf != NULL);
+
     /* cleanup old data if there is any */
-    if (buf->bufstart) {
+    if (buf->bufstart)
+    {
         free(buf->bufstart);
         buf->bufstart = NULL;
         free(buf->path);
@@ -175,28 +180,40 @@ void buf_init(Buf* buf) {
     buf->redo      = NULL;
     buf->transid   = -1;
     buf->selection = (Sel){0,0,0};
+
     ensure(buf_valid(buf));
 }
 
-void buf_setpath(Buf* buf, char* path) {
-    if (path) {
+void buf_setpath(Buf* buf, char* path)
+{
+    require(buf != NULL);
+    if (path)
+    {
         free(buf->path);
         buf->path = strdup(path);
         ensure(buf->path != NULL);
     }
 }
 
-void buf_load(Buf* buf, char* path) {
-    if (!path) return;
+void buf_load(Buf* buf, char* path)
+{
+    if (!path)
+    {
+        return;
+    }
+
     /* process the file path and address */
     if (path[0] == '.' && path[1] == '/')
+    {
         path += 2;
+    }
     buf->path = strdup(path);
 
     /* load the contents from the file */
     int fd, nread;
     struct stat sb = {0};
-    if (((fd = open(path, O_RDONLY, 0)) >= 0) && (fstat(fd, &sb) >= 0) && (sb.st_size > 0)) {
+    if (((fd = open(path, O_RDONLY, 0)) >= 0) && (fstat(fd, &sb) >= 0) && (sb.st_size > 0))
+    {
         /* allocate the buffer in advance */
         free(buf->bufstart);
         buf->bufsize  = pagealign(sb.st_size);
@@ -208,7 +225,10 @@ void buf_load(Buf* buf, char* path) {
         while (sb.st_size && (nread = read(fd, buf->gapstart, sb.st_size)) > 0)
             buf->gapstart += nread, sb.st_size -= nread;
     }
-    if (fd > 0) close(fd);
+    if (fd > 0)
+    {
+        close(fd);
+    }
 
     /* reset buffer state */
     buf->status  = NORMAL;
@@ -221,25 +241,36 @@ void buf_load(Buf* buf, char* path) {
     ensure(buf_valid(buf));
 }
 
-void buf_reload(Buf* buf) {
+void buf_reload(Buf* buf)
+{
     char* path = buf->path;
     buf->path = NULL;
     buf_init(buf);
     buf_load(buf, path);
 }
 
-static void trim_whitespace(Buf* buf) {
-    if (!TrimOnSave || !buf_end(buf)) return;
+static void trim_whitespace(Buf* buf)
+{
+    if (!TrimOnSave || !buf_end(buf))
+    {
+        return;
+    }
     Sel sel = buf->selection;
     bool swapped = (sel.beg > sel.end);
-    if (swapped) sel = selswap(sel);
+    if (swapped)
+    {
+        sel = selswap(sel);
+    }
+
     unsigned prev = 1;
     buf->selection.beg = buf->selection.end = 0;
     buf_logstart(buf);
-    while (prev != buf->selection.end) {
+    while (prev != buf->selection.end)
+    {
         int r = getb(buf, buf->selection.end);
         /* If we reached a newline, then delete whatever we have selected */
-        if (r == '\r' || r == '\n') {
+        if (r == '\r' || r == '\n')
+        {
             buf->selection.beg = buf_byrune(buf, buf->selection.beg, +1);
             Sel del = buf->selection;
             sel.beg -= (del.beg < sel.beg ? (min(del.end, sel.beg) - del.beg) : 0);
@@ -249,26 +280,36 @@ static void trim_whitespace(Buf* buf) {
 
         /* if current char is not whitespace, then shrink the selection */
         if (r != ' ' && r != '\t')
+        {
             buf->selection.beg = buf->selection.end;
+        }
 
         /* move to the next character */
         prev = buf->selection.end;
         buf->selection.end = buf_byrune(buf, buf->selection.end, +1);
     }
     buf_logstop(buf);
-    if (swapped) sel = selswap(sel);
+    if (swapped)
+    {
+        sel = selswap(sel);
+    }
     buf->selection = sel;
 }
 
-int buf_save(Buf* buf, char* path) {
+int buf_save(Buf* buf, char* path)
+{
     buf_setpath(buf, path);
-    if (0 == buf_end(buf)) return buf->status;
+    if (0 == buf_end(buf))
+    {
+        return buf->status;
+    }
 
     trim_whitespace(buf);
 
     char* wptr;
     long fd, nwrite = 0, towrite = 0;
-    if (buf->path && (fd = open(buf->path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) >= 0) {
+    if (buf->path && (fd = open(buf->path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) >= 0)
+    {
         /* write the chunk before the gap */
         wptr = buf->bufstart, towrite = (buf->gapstart - buf->bufstart);
         while (towrite && ((nwrite = write(fd, wptr, towrite)) > 0))
@@ -280,11 +321,16 @@ int buf_save(Buf* buf, char* path) {
         close(fd);
         /* report success or failure */
         buf->status = (nwrite >= 0 ? NORMAL : ERRORED);
-    } else {
+    }
+    else
+    {
         buf->status = ERRORED;
     }
+
     if (buf->status == NORMAL)
+    {
         buf->save = buf->undo;
+    }
 
     ensure(buf_valid(buf));
     return buf->status;
@@ -292,7 +338,8 @@ int buf_save(Buf* buf, char* path) {
 
 /* Undo/Redo Operations
  ******************************************************************************/
-static Log* mklog(Buf* buf, size_t beg, size_t end, char* data, Log* next) {
+static Log* mklog(Buf* buf, size_t beg, size_t end, char* data, Log* next)
+{
     Log* log = calloc(1, sizeof(Log));
     log->transid = (buf->transid < 0 ? 0 : buf->transid);
     log->beg = beg;
@@ -302,69 +349,100 @@ static Log* mklog(Buf* buf, size_t beg, size_t end, char* data, Log* next) {
     return log;
 }
 
-static void log_clear(Log** list) {
-    while (*list) {
+static void log_clear(Log** list)
+{
+    while (*list)
+    {
         Log* deadite = *list;
         *list = (*list)->next;
         if (deadite->data)
+        {
             free(deadite->data);
+        }
         free(deadite);
     }
 }
 
-static void dumplog(Buf* buf) {
+static void dumplog(Buf* buf)
+{
 #if 0
     printf("\nUndo:\n");
     for (Log* log = buf->undo; log; log = log->next)
+    {
         printf("    (%d) %lu-%lu '%s'\n", log->transid, log->beg, log->end, log->data);
+    }
     printf("Redo:\n");
     for (Log* log = buf->redo; log; log = log->next)
+    {
         printf("    (%d) %lu-%lu '%s'\n", log->transid, log->beg, log->end, log->data);
+    }
 #else
     (void)buf;
 #endif
 }
 
-static void log_add(Buf* buf, size_t beg, size_t end, char* data) {
+static void log_add(Buf* buf, size_t beg, size_t end, char* data)
+{
     Log* prev = buf->undo;
     log_clear(&(buf->redo));
+
     /* decide if this is an insert or delete */
-    if (!prev || (buf->transid > 0 && buf->transid != prev->transid)) {
+    if (!prev || (buf->transid > 0 && buf->transid != prev->transid))
+    {
         buf->undo = mklog(buf, beg, end, data, prev);
-    } else if (!data && !prev->data && prev->end == beg) {
+    }
+    else if (!data && !prev->data && prev->end == beg)
+    {
         prev->end = end;
-    } else if (prev->data && data && prev->beg == beg) {
+    }
+    else if (prev->data && data && prev->beg == beg)
+    {
         char* newdata = strmcat(prev->data, data, 0);
         free(data);
         free(prev->data);
         prev->data = newdata;
-    } else if (prev->data && data && prev->beg == beg+1) {
+    }
+    else if (prev->data && data && prev->beg == beg+1)
+    {
         char* newdata = strmcat(data, prev->data, 0);
         free(data);
         free(prev->data);
         prev->data = newdata;
         prev->end = --prev->beg;
-    } else {
+    }
+    else
+    {
         buf->undo = mklog(buf, beg, end, data, prev);
     }
+
     dumplog(buf);
 }
 
-static void log_swap(Buf* buf, Log** src, Log** dest) {
-    if (!*src) return;
+static void log_swap(Buf* buf, Log** src, Log** dest)
+{
+    if (!*src)
+    {
+        return;
+    }
+
     Log* item = *src;
     *src = item->next;
     buf->selection.beg = item->beg;
     buf->selection.end = item->end;
-    if (item->data) {
+    if (item->data)
+    {
         /* reinsert deleted bytes */
         for (char* s = item->data; s && *s; s++, item->end++)
+        {
             putb(buf, *s, &(buf->selection));
+        }
         free(item->data);
         item->data = NULL;
         buf->selection.beg = item->beg;
         buf->selection.end = item->end;
-   } else {
+   }
+   else
+   {
         /* delete the added bytes */
         Sel sel = selget(buf);
         item->data = buf_gets(buf);
@@ -375,58 +453,91 @@ static void log_swap(Buf* buf, Log** src, Log** dest) {
         item->beg = sel.beg;
         item->end = sel.end;
     }
+
     /* push item onto destination stack */
     item->next = *dest;
     *dest = item;
     /* undo recursively if this is part of a transaction */
     if (*src && item->transid && item->transid == (*src)->transid)
+    {
         log_swap(buf, src, dest);
+    }
     else
+    {
         dumplog(buf);
+    }
+
     if (buf->save == buf->undo)
+    {
         buf->status = NORMAL;
+    }
 }
 
-void buf_logstart(Buf* buf) {
+void buf_logstart(Buf* buf)
+{
     buf->transid = abs(buf->transid);
 }
 
-void buf_logstop(Buf* buf) {
+void buf_logstop(Buf* buf)
+{
     if (buf->transid > 0)
+    {
         buf->transid = -(buf->transid + 1);
+    }
 }
 
-void buf_undo(Buf* buf) {
+void buf_undo(Buf* buf)
+{
     log_swap(buf, &(buf->undo), &(buf->redo));
     ensure(buf_valid(buf));
 }
 
-void buf_redo(Buf* buf) {
+void buf_redo(Buf* buf)
+{
     log_swap(buf, &(buf->redo), &(buf->undo));
     ensure(buf_valid(buf));
 }
 
-void buf_logclear(Buf* buf) {
+void buf_logclear(Buf* buf)
+{
     log_clear(&(buf->redo));
     log_clear(&(buf->undo));
 }
 
-void buf_lastins(Buf* buf) {
+void buf_lastins(Buf* buf)
+{
     Log* log = buf->undo;
-    if (!log) return;
+    if (!log)
+    {
+        return;
+    }
     Sel sel = {.beg = log->beg, .end = log->end };
     size_t delsize = 0;
     int transid = log->transid;
+
     /* try and expand the selected region to encompass related inserts */
-    for (; log && (log->transid == transid); log = log->next) {
-        if (!log->data) {
+    for (; log && (log->transid == transid); log = log->next)
+    {
+        if (!log->data)
+        {
             size_t ibeg = log->beg, iend = log->end - delsize;
-            if (iend < ibeg || ibeg > sel.beg || iend < sel.beg) break;
-            if (ibeg < sel.beg && iend > sel.end) break;
+            if (iend < ibeg || ibeg > sel.beg || iend < sel.beg)
+            {
+                break;
+            }
+            if (ibeg < sel.beg && iend > sel.end)
+            {
+                break;
+            }
             sel.beg = ibeg, delsize = 0;
-        } else {
+        }
+        else
+        {
             /* bail if the delete doesnt overlap */
-            if(log->beg != sel.beg) break;
+            if (log->beg != sel.beg)
+            {
+                break;
+            }
             delsize = strlen(log->data);
         }
     }
@@ -435,54 +546,73 @@ void buf_lastins(Buf* buf) {
 
 /* Basic Operations and Accessors
  ******************************************************************************/
-size_t buf_end(Buf* buf) {
+size_t buf_end(Buf* buf)
+{
     size_t bufsz = buf->bufend - buf->bufstart;
     size_t gapsz = buf->gapend - buf->gapstart;
     return (bufsz - gapsz);
 }
 
-int buf_getrat(Buf* buf, size_t off) {
+int buf_getrat(Buf* buf, size_t off)
+{
     size_t rlen = 0;
     Rune rune = 0;
     if (getb(buf, off) == '\r' && getb(buf, off+1) == '\n')
+    {
         rune = '\n';
+    }
     else
-        while (!utf8decode(&rune, &rlen, getb(buf, off++)));
+    {
+        while ( !utf8decode(&rune, &rlen, getb(buf, off++)) )
+        {
+        }
+    }
     return rune;
 }
 
-void buf_putc(Buf* buf, int c) {
+void buf_putc(Buf* buf, int c)
+{
     char utf8buf[UTF_MAX+1] = {0};
     (void)utf8encode(utf8buf, c);
     buf_puts(buf, utf8buf);
     ensure(buf_valid(buf));
 }
 
-void buf_puts(Buf* buf, char* s) {
+void buf_puts(Buf* buf, char* s)
+{
     buf_del(buf);
     size_t beg = buf_selbeg(buf);
-    if (s && *s) {
-        while (*s) putch(buf, *(s++), &(buf->selection));
+    if (s && *s)
+    {
+        while (*s)
+        {
+            putch(buf, *(s++), &(buf->selection));
+        }
         log_add(buf, beg, buf_selend(buf), NULL);
     }
     ensure(buf_valid(buf));
 }
 
-int buf_getc(Buf* buf) {
+int buf_getc(Buf* buf)
+{
     return buf_getrat(buf, buf->selection.end);
 }
 
-char* buf_gets(Buf* buf) {
+char* buf_gets(Buf* buf)
+{
     Sel sel = selget(buf);
     size_t nbytes = sel.end - sel.beg;
     char* str = malloc(nbytes+1);
     for (size_t i = 0; i < nbytes; i++)
+    {
         str[i] = getb(buf, sel.beg + i);
+    }
     str[nbytes] = '\0';
     return str;
 }
 
-char* buf_getsat(Buf* buf, size_t beg, size_t end) {
+char* buf_getsat(Buf* buf, size_t beg, size_t end)
+{
     Sel sel = selget(buf);
     buf->selection = (Sel){ .beg = beg, .end = end };
     char* str = buf_gets(buf);
@@ -490,10 +620,12 @@ char* buf_getsat(Buf* buf, size_t beg, size_t end) {
     return str;
 }
 
-void buf_del(Buf* buf) {
+void buf_del(Buf* buf)
+{
     Sel sel = selget(buf);
     size_t nbytes = sel.end - sel.beg;
-    if (nbytes > 0) {
+    if (nbytes > 0)
+    {
         buf->status = MODIFIED;
         char* str = buf_gets(buf);
         buf_syncgap(buf, sel.beg);
@@ -507,17 +639,23 @@ void buf_del(Buf* buf) {
 
 /* Positional and Movement Operations
  ******************************************************************************/
-static Rune nextrune(Buf* buf, size_t off, int move, bool (*testfn)(Rune)) {
+static Rune nextrune(Buf* buf, size_t off, int move, bool (*testfn)(Rune))
+{
     bool ret = false;
     size_t end = buf_end(buf);
     if (move < 0 && off > 0)
+    {
         ret = testfn(buf_getrat(buf, off-1));
+    }
     else if (move > 0 && off < end)
+    {
         ret = testfn(buf_getrat(buf, off+1));
+    }
     return ret;
 }
 
-static void selline(Buf* buf) {
+static void selline(Buf* buf)
+{
     Sel sel = selget(buf);
     sel.beg = buf_bol(buf, sel.end);
     sel.end = buf_eol(buf, sel.end);
@@ -525,185 +663,295 @@ static void selline(Buf* buf) {
     buf->selection = sel;
 }
 
-static void selblock(Buf* buf, Rune first, Rune last) {
+static void selblock(Buf* buf, Rune first, Rune last)
+{
     Sel sel = selget(buf);
     int balance = 0, dir;
     size_t beg, end = sel.end;
 
     /* figure out which end of the block we're starting at */
     if (buf_getrat(buf, end) == first)
+    {
         dir = +1, balance++, beg = end++;
+    }
     else if (buf_getrat(buf, end) == last)
+    {
         dir = -1, balance--, beg = end--;
+    }
     else
+    {
         return;
+    }
 
     /* scan for a blanced set of braces */
-    while (true) {
+    while (true)
+    {
         if (buf_getrat(buf, end) == first)
+        {
             balance++;
+        }
         else if (buf_getrat(buf, end) == last)
+        {
             balance--;
+        }
 
         if (balance == 0 || end >= buf_end(buf) || end == 0)
+        {
             break;
+        }
         else
+        {
             end += dir;
+        }
     }
 
     /* bail if we failed to find a block */
-    if (balance != 0) return;
+    if (balance != 0)
+    {
+        return;
+    }
 
     /* update the passed in selection */
-    if (end > beg) beg++; else end++;
-    buf->selection.beg = beg, buf->selection.end = end;
+    if (end > beg)
+    {
+        beg++;
+    }
+    else
+    {
+        end++;
+    }
+    buf->selection.beg = beg;
+    buf->selection.end = end;
 }
 
-static int bytes_match(Buf* buf, size_t mbeg, size_t mend, char* str) {
-    for (; *str && mbeg < mend; str++, mbeg++) {
+static int bytes_match(Buf* buf, size_t mbeg, size_t mend, char* str)
+{
+    for (; *str && mbeg < mend; str++, mbeg++)
+    {
         int cmp = *str - getb(buf, mbeg);
-        if (cmp != 0) return cmp;
+        if (cmp != 0)
+        {
+            return cmp;
+        }
     }
     return 0;
 }
 
-bool buf_isbol(Buf* buf, size_t off) {
+bool buf_isbol(Buf* buf, size_t off)
+{
     size_t bol = buf_bol(buf, off);
     return (bol == off);
 }
 
-bool buf_iseol(Buf* buf, size_t off) {
+bool buf_iseol(Buf* buf, size_t off)
+{
     Rune r = buf_getrat(buf, off);
     return (r == '\r' || r == '\n');
 }
 
-size_t buf_bol(Buf* buf, size_t off) {
-    for (; !buf_iseol(buf, off-1); off--);
+size_t buf_bol(Buf* buf, size_t off)
+{
+    for (; !buf_iseol(buf, off-1); off--)
+    {
+    }
     return off;
 }
 
-size_t buf_eol(Buf* buf, size_t off) {
-    for (; !buf_iseol(buf, off); off++);
+size_t buf_eol(Buf* buf, size_t off)
+{
+    for (; !buf_iseol(buf, off); off++)
+    {
+    }
     return off;
 }
 
-void buf_selword(Buf* buf, bool (*isword)(Rune)) {
+void buf_selword(Buf* buf, bool (*isword)(Rune))
+{
     Sel sel = selget(buf);
-    for (; isword(buf_getrat(buf, sel.beg-1)); sel.beg--);
-    for (; isword(buf_getrat(buf, sel.end));   sel.end++);
+    for (; isword(buf_getrat(buf, sel.beg-1)); sel.beg--)
+    {
+    }
+    for (; isword(buf_getrat(buf, sel.end));   sel.end++)
+    {
+    }
     buf->selection = sel;
 }
 
-void buf_selall(Buf* buf) {
+void buf_selall(Buf* buf)
+{
     buf->selection = (Sel){ .beg = 0, .end = buf_end(buf) };
 }
 
-static bool selquote(Buf* buf, Rune c) {
+static bool selquote(Buf* buf, Rune c)
+{
     Rune curr = buf_getc(buf);
     size_t nextoff = buf_byrune(buf, buf->selection.end, RIGHT);
     Rune prev = buf_getrat(buf, buf_byrune(buf, buf->selection.end, LEFT));
     Rune next = buf_getrat(buf, buf_byrune(buf, buf->selection.end, RIGHT));
-    if (prev == c || curr == c) {
+    if (prev == c || curr == c)
+    {
         size_t bend = buf_end(buf);
         buf->selection.beg = buf->selection.end = (prev == c ? buf->selection.end : nextoff);
         size_t selend = buf->selection.end;
-        for (; selend < bend && buf_getrat(buf, selend) != c; selend = buf_byrune(buf, selend, RIGHT));
+        for (; selend < bend && buf_getrat(buf, selend) != c; selend = buf_byrune(buf, selend, RIGHT))
+        {
+        }
         if (buf_getrat(buf, selend) == c)
+        {
             buf->selection.end = selend;
+        }
         return true;
-    } else if (next == c) {
+    }
+    else if (next == c)
+    {
         buf->selection.beg = buf->selection.end;
         buf->selection.end = nextoff;
         size_t selbeg = buf->selection.beg;
-        for (; selbeg > 0 && buf_getrat(buf, selbeg) != c; selbeg = buf_byrune(buf, selbeg, LEFT));
+        for (; selbeg > 0 && buf_getrat(buf, selbeg) != c; selbeg = buf_byrune(buf, selbeg, LEFT))
+        {
+        }
         if (buf_getrat(buf, selbeg) == c)
+        {
             buf->selection.beg = buf_byrune(buf, selbeg, RIGHT);
+        }
         return true;
     }
     return false;
 }
 
-void buf_selctx(Buf* buf, bool (*isword)(Rune)) {
+void buf_selctx(Buf* buf, bool (*isword)(Rune))
+{
     size_t bol = buf_bol(buf, buf->selection.end);
     Rune curr = buf_getc(buf);
     if (curr == '(' || curr == ')')
+    {
         selblock(buf, '(', ')');
+    }
     else if (curr == '[' || curr == ']')
+    {
         selblock(buf, '[', ']');
+    }
     else if (curr == '{' || curr == '}')
+    {
         selblock(buf, '{', '}');
+    }
     else if (curr == '<' || curr == '>')
+    {
         selblock(buf, '<', '>');
+    }
     else if (buf->selection.end == bol || curr == '\n')
+    {
         selline(buf);
+    }
     else if (selquote(buf, '"') || selquote(buf, '`') || selquote(buf, '\''))
+    {
         ; /* condition performs selection */
+    }
     else if (risword(curr))
+    {
         buf_selword(buf, isword);
+    }
     else
+    {
         buf_selword(buf, risbigword);
+    }
     buf_getcol(buf);
 }
 
-size_t buf_byrune(Buf* buf, size_t pos, int count) {
+size_t buf_byrune(Buf* buf, size_t pos, int count)
+{
     int move = (count < 0 ? -1 : 1);
     count *= move; // remove the sign if there is one
-    for (; count > 0; count--) {
-        if (pos > 0 && move < 0) {
+    for (; count > 0; count--)
+    {
+        if (pos > 0 && move < 0)
+        {
             if (getb(buf, pos-2) == '\r' && getb(buf, pos-1) == '\n')
+            {
                 pos -= 2;
+            }
             else
+            {
                 pos += move;
-        } else if (pos < buf_end(buf) && move > 0) {
+            }
+        }
+        else if (pos < buf_end(buf) && move > 0)
+        {
             if (getb(buf, pos) == '\r' && getb(buf, pos+1) == '\n')
+            {
                 pos += 2;
+            }
             else
+            {
                 pos += move;
+            }
         }
     }
     return pos;
 }
 
-size_t buf_byword(Buf* buf, size_t off, int count) {
+size_t buf_byword(Buf* buf, size_t off, int count)
+{
     int move = (count < 0 ? -1 : 1);
 
     while (nextrune(buf, off, move, risblank))
+    {
         off = buf_byrune(buf, off, move);
+    }
 
-    if (nextrune(buf, off, move, risword)) {
+    if (nextrune(buf, off, move, risword))
+    {
         while (nextrune(buf, off, move, risword))
+        {
             off = buf_byrune(buf, off, move);
+        }
+
         if (move > 0)
+        {
             off = buf_byrune(buf, off, move);
-    } else {
+        }
+    }
+    else
+    {
         off = buf_byrune(buf, off, move);
     }
 
     return off;
 }
 
-size_t buf_byline(Buf* buf, size_t pos, int count) {
+size_t buf_byline(Buf* buf, size_t pos, int count)
+{
     int move = (count < 0 ? -1 : 1);
     count *= move; // remove the sign if there is one
-    for (; count > 0; count--) {
-        if (move < 0) {
+    for (; count > 0; count--)
+    {
+        if (move < 0)
+        {
             if (pos > buf_eol(buf, 0))
+            {
                 pos = buf_byrune(buf, buf_bol(buf, pos), LEFT);
-        } else {
+            }
+        }
+        else
+        {
             size_t next = buf_byrune(buf, buf_eol(buf, pos), RIGHT);
             if (next <= buf_end(buf))
+            {
                 pos = next;
+            }
         }
     }
     return pos;
 }
 
-bool buf_findstr(Buf* buf, int dir, char* str) {
+bool buf_findstr(Buf* buf, int dir, char* str)
+{
     size_t len = strlen(str);
     size_t start = buf->selection.beg,
            mbeg = (start + dir),
            mend = (mbeg + len);
-    while (mbeg != start) {
+    while (mbeg != start)
+    {
         if ((getb(buf, mbeg) == str[0]) &&
             (getb(buf, mend-1) == str[len-1]) &&
             (0 == bytes_match(buf, mbeg, mend, str)))
@@ -713,112 +961,157 @@ bool buf_findstr(Buf* buf, int dir, char* str) {
         }
         mbeg += dir, mend += dir;
         if (mend > buf_end(buf))
+        {
             mbeg = (dir < 0 ? buf_end(buf)-len : 0), mend = mbeg + len;
+        }
     }
     return false;
 }
 
-void buf_setln(Buf* buf, size_t line) {
+void buf_setln(Buf* buf, size_t line)
+{
     size_t curr = 0, end = buf_end(buf);
-    while (line > 1 && curr < end) {
+    while (line > 1 && curr < end)
+    {
         size_t next = buf_byline(buf, curr, DOWN);
-        if (curr == next) break;
+        if (curr == next)
+        {
+            break;
+        }
         line--, curr = next;
     }
-    buf->selection.beg = buf->selection.end = curr;
+    buf->selection.beg = curr;
+    buf->selection.end = curr;
 }
 
-void buf_getln(Buf* buf, size_t* begln, size_t* endln) {
+void buf_getln(Buf* buf, size_t* begln, size_t* endln)
+{
     size_t line = 1, curr = 0, end = buf_end(buf);
     size_t sbeg = buf_selbeg(buf), send = buf_selend(buf);
-    while (curr < end) {
+    while (curr < end)
+    {
         size_t next = buf_byline(buf, curr, DOWN);
-        if (curr <= sbeg && sbeg < next) {
+
+        if (curr <= sbeg && sbeg < next)
+        {
             *begln = line, *endln = line;
         }
-        if (curr <= send && send < next) {
+
+        if (curr <= send && send < next)
+        {
             *endln = line;
             break;
         }
-        if (curr == next) break;
-        line++, curr = next;
+
+        if (curr == next)
+        {
+            break;
+        }
+        line++;
+        curr = next;
     }
 }
 
-void buf_getcol(Buf* buf) {
+void buf_getcol(Buf* buf)
+{
     Sel sel = buf->selection;
     size_t pos = sel.end, curr = buf_bol(buf, pos);
     for (sel.col = 0; curr < pos; curr = buf_byrune(buf, curr, 1))
+    {
         sel.col += runewidth(sel.col, buf_getrat(buf, curr));
+    }
     buf->selection = sel;
 }
 
-void buf_setcol(Buf* buf) {
+void buf_setcol(Buf* buf)
+{
     Sel sel = buf->selection;
     size_t bol = buf_bol(buf, sel.end);
     size_t curr = bol, len = 0, i = 0;
+
     /* determine the length of the line in columns */
     for (; !buf_iseol(buf, curr); curr++)
+    {
         len += runewidth(len, buf_getrat(buf, curr));
+    }
+
     /* iterate over the runes until we reach the target column */
-    for (sel.end = bol, i = 0; i < sel.col && i < len;) {
+    for (sel.end = bol, i = 0; i < sel.col && i < len;)
+    {
         int width = runewidth(i, buf_getrat(buf, sel.end));
         sel.end = buf_byrune(buf, sel.end, 1);
         if (sel.col >= i && sel.col < (i + width))
+        {
             break;
+        }
         i += width;
     }
     buf->selection = sel;
 }
 
-size_t buf_selbeg(Buf* buf) {
+size_t buf_selbeg(Buf* buf)
+{
     return selget(buf).beg;
 }
 
-size_t buf_selend(Buf* buf) {
+size_t buf_selend(Buf* buf)
+{
     return selget(buf).end;
 }
 
-size_t buf_selsz(Buf* buf) {
+size_t buf_selsz(Buf* buf)
+{
     return (selget(buf).end - selget(buf).beg);
 }
 
-void buf_selln(Buf* buf) {
+void buf_selln(Buf* buf)
+{
     /* Expand the selection to completely select the lines covered */
     Sel sel = selget(buf);
     sel.beg = buf_bol(buf, sel.beg);
-    if (!buf_iseol(buf, sel.end-1) || sel.end == sel.beg) {
+    if (!buf_iseol(buf, sel.end-1) || sel.end == sel.beg)
+    {
         sel.end = buf_eol(buf, sel.end);
         sel.end = buf_byrune(buf, sel.end, RIGHT);
     }
     buf->selection = sel;
 }
 
-void buf_selclr(Buf* buf, int dir) {
+void buf_selclr(Buf* buf, int dir)
+{
     require(buf != NULL);
     Sel sel = selget(buf);
     if (dir > 0)
+    {
         sel.beg = sel.end;
+    }
     else
+    {
         sel.end = sel.beg;
+    }
     buf->selection = sel;
 }
 
-bool buf_insel(Buf* buf, size_t off) {
+bool buf_insel(Buf* buf, size_t off)
+{
     require(buf != NULL);
     return (off >= buf_selbeg(buf) && off < buf_selend(buf));
 }
 
-char* buf_fetch(Buf* buf, bool (*isword)(Rune), size_t off) {
+char* buf_fetch(Buf* buf, bool (*isword)(Rune), size_t off)
+{
     require(buf != NULL);
     require(isword != NULL);
     char* str = NULL;
     Sel prev = buf->selection;
-    if (!buf_insel(buf, off)) {
+    if (!buf_insel(buf, off))
+    {
         buf->selection = (Sel){ .beg = off, .end = off };
         buf_selword(buf, isword);
         str = buf_gets(buf);
-    } else {
+    }
+    else
+    {
         str = buf_gets(buf);
     }
     buf->selection = prev;
-- 
2.52.0