From: Michael D. Lowis <mike.lowis@gentex.com>
Date: Mon, 30 Sep 2019 20:16:37 +0000 (-0400)
Subject: applied brace style to view.c
X-Git-Url: https://git.mdlowis.com/?a=commitdiff_plain;h=1c74ff5bbf3cd2f425252374650aab92f702aff5;p=projs%2Ftide.git

applied brace style to view.c
---

diff --git a/TODO.md b/TODO.md
index bc124a8..2defc37 100644
--- a/TODO.md
+++ b/TODO.md
@@ -4,13 +4,16 @@
 
 ## STAGING
 
+* tide: refactor byword, byline, etc api
+* tide: refactor undo/redo api in view.c
+* all: eliminate multiple return statements
+
+## BACKLOG
+
 * anvil: support moving floating windows
 * anvil: add support for multiple workspaces
 * anvil: add column support
 * anvil: add support for multiple monitors
-
-## BACKLOG
-
 * anvil: add support for session management
 * tide: add support for session management
 * tide: implement drag and drop support
diff --git a/src/lib/view.c b/src/lib/view.c
index ba4a5b1..8cffbff 100644
--- a/src/lib/view.c
+++ b/src/lib/view.c
@@ -6,7 +6,8 @@
 #include "config.h"
 
 #ifndef NDEBUG
-static bool view_valid(View* view) {
+static bool view_valid(View* view)
+{
     return (
            (view->sync_flags <= 3u)
         && (!view->nrows || view->index < view->nrows)
@@ -26,71 +27,102 @@ extern size_t glyph_width(View* view, int c);
 
 typedef size_t (*movefn_t)(Buf* buf, size_t pos, int count);
 
-static void move_selection(View* view, bool extsel, int move, movefn_t bything) {
+static void move_selection(View* view, bool extsel, int move, movefn_t bything)
+{
     view->sync_flags |= CURSOR;
-    if (buf_selsz(BUF) && !extsel) {
+    if (buf_selsz(BUF) && !extsel)
+    {
         buf_selclr(BUF, move);
         buf_getcol(BUF);
-        if (bything == buf_byline) {
+        if (bything == buf_byline)
+        {
             CSRPOS = bything(BUF, CSRPOS, move);
             buf_setcol(BUF);
             if (!extsel)
+            {
                 buf_selclr(BUF, (move < 0 ? LEFT : RIGHT));
+            }
         }
-    } else {
+    }
+    else
+    {
         CSRPOS = bything(BUF, CSRPOS, move);
         if (bything == buf_byline)
+        {
             buf_setcol(BUF);
+        }
+
         if (!extsel)
+        {
             buf_selclr(BUF, (move < 0 ? LEFT : RIGHT));
+        }
+
         /* only update column if not moving vertically */
         if (bything != buf_byline)
+        {
             buf_getcol(BUF);
+        }
     }
 }
 
-static void move_to(View* view, bool extsel, size_t off) {
+static void move_to(View* view, bool extsel, size_t off)
+{
     Buf* buf = BUF;
     off = (off > buf_end(buf) ? buf_end(buf) : off);
     int dir = (off < CSRPOS ? LEFT : RIGHT);
     CSRPOS = off;
     if (!extsel)
+    {
         buf_selclr(BUF, dir);
+    }
     buf_getcol(buf);
     view->sync_flags |= CURSOR;
 }
 
-static bool selection_visible(View* view) {
-    if (!view->rows || !view->nrows) return true;
+static bool selection_visible(View* view)
+{
+    if (!view->rows || !view->nrows)
+    {
+        return true;
+    }
     size_t csr = CSRPOS;
     size_t beg = view->rows[0]->off;
-    size_t end = view->rows[view->nrows-1]->off +
-                 view->rows[view->nrows-1]->len;
+    size_t end = view->rows[view->nrows-1]->off
+               + view->rows[view->nrows-1]->len;
     return (beg <= csr && csr <= end);
 }
 
-static Sel* getsel(View* view) {
+static Sel* getsel(View* view)
+{
     return &(view->buffer.selection);
 }
 
-static void clear_rows(View* view, size_t startidx) {
-    if (view->rows) {
+static void clear_rows(View* view, size_t startidx)
+{
+    if (view->rows)
+    {
         /* Free and clear invalid rows now */
-        for (size_t i = startidx; i < view->nrows; i++) {
+        for (size_t i = startidx; i < view->nrows; i++)
+        {
             free(view->rows[i]);
             view->rows[i] = NULL;
         }
         /* grow row array if needed */
         if (startidx > view->nrows)
+        {
             view->rows = realloc(view->rows, startidx);
+        }
         /* zero out newly created slots */
         for (size_t i = view->nrows; i < startidx; i++)
+        {
             view->rows[i] = NULL;
+        }
         view->nrows = startidx;
     }
 }
 
-void view_init(View* view, char* file) {
+void view_init(View* view, char* file)
+{
     require(view != NULL);
     clear_rows(view, 0);
     view->sync_flags |= (CURSOR|CENTER);
@@ -99,48 +131,71 @@ void view_init(View* view, char* file) {
     view->nvisible = 0;
     /* load the file and jump to the address returned from the load function */
     buf_init(BUF);
-    if (file) buf_load(BUF, file);
+    if (file)
+    {
+        buf_load(BUF, file);
+    }
     ensure(view_valid(view));
 }
 
-void view_reload(View* view) {
+void view_reload(View* view)
+{
     require(view != NULL);
-    if (view->buffer.path) {
+    if (view->buffer.path)
+    {
         buf_reload(BUF);
         view->sync_flags |= (CURSOR|CENTER);
     }
     ensure(view_valid(view));
 }
 
-void view_sync(View* view) {
+void view_sync(View* view)
+{
     require(view != NULL);
     view->sync_flags |= (CURSOR|CENTER);
     ensure(view_valid(view));
 }
 
-static size_t rune_width(View* view, int c, size_t xpos, size_t width) {
+static size_t rune_width(View* view, int c, size_t xpos, size_t width)
+{
     if (c == '\r')
+    {
         return 0;
+    }
     else if (c == '\n')
+    {
         return (width-xpos);
+    }
     else if (c == '\t')
+    {
         return (glyph_width(view, c) - (xpos % glyph_width(view, c)));
+    }
     else
+    {
         return glyph_width(view, c);
+    }
 }
 
-size_t view_limitrows(View* view, size_t maxrows) {
+size_t view_limitrows(View* view, size_t maxrows)
+{
     require(view != NULL);
     size_t nrows = 1, off = 0, xpos = 0;
-    while (nrows < maxrows && off < buf_end(&(view->buffer))) {
+    while (nrows < maxrows && off < buf_end(&(view->buffer)))
+    {
         Rune rune = buf_getrat(&(view->buffer), off);
         xpos += rune_width(view, rune, xpos, view->width);
         /* if the line is full, reset the line and increase row count */
-        if (xpos > view->width) {
+        if (xpos > view->width)
+        {
             xpos = 0, nrows++;
-        } else {
+        }
+        else
+        {
             if (rune == '\n')
-                xpos = 0, nrows++;
+            {
+                xpos = 0;
+                nrows++;
+            }
             off = buf_byrune(&(view->buffer), off, RIGHT);
         }
     }
@@ -148,18 +203,22 @@ size_t view_limitrows(View* view, size_t maxrows) {
     return nrows;
 }
 
-static size_t add_row(View* view, size_t off) {
+static size_t add_row(View* view, size_t off)
+{
     /* allocate a new row */
     view->nrows++;
     view->rows = realloc(view->rows, sizeof(Row*) * view->nrows);
     view->rows[view->nrows-1] = calloc(1, sizeof(Row));
     view->rows[view->nrows-1]->off = off;
+
     /* populate the row with characters */
-    for (size_t xpos = 0; xpos < view->width;) {
+    for (size_t xpos = 0; xpos < view->width;)
+    {
         int rune = buf_getrat(&(view->buffer), off);
         size_t rwidth = rune_width(view, rune, xpos, view->width);
         xpos += rwidth;
-        if (xpos <= view->width) {
+        if (xpos <= view->width)
+        {
             size_t len = view->rows[view->nrows-1]->len + 1;
             view->rows[view->nrows-1] = realloc(
                 view->rows[view->nrows-1], sizeof(Row) + (len * sizeof(UGlyph)));
@@ -173,7 +232,8 @@ static size_t add_row(View* view, size_t off) {
     return off;
 }
 
-static void resize(View* view, size_t width, size_t nrows, size_t off) {
+static void resize(View* view, size_t width, size_t nrows, size_t off)
+{
     bool first_line_done = false;
     clear_rows(view, 0);
     view->width = width;
@@ -181,172 +241,234 @@ static void resize(View* view, size_t width, size_t nrows, size_t off) {
     view->index = 0;
     size_t beg = off, bend = buf_end(&(view->buffer));
     off = buf_bol(&(view->buffer), off);
-    if (off > bend) off = bend;
-    for (size_t i = 0; nrows > 0; i++) {
+    if (off > bend)
+    {
+        off = bend;
+    }
+
+    for (size_t i = 0; nrows > 0; i++)
+    {
         off = add_row(view, off);
         Row* row = view->rows[view->nrows-1];
         first_line_done = (first_line_done || (row->cols[row->len-1].rune == '\n'));
         if (first_line_done)
+        {
             nrows--;
+        }
         if (beg < bend && beg >= row->off && beg <= row->cols[row->len-1].off)
+        {
             view->index = i;
+        }
     }
 }
 
-void view_resize(View* view, size_t width, size_t nrows) {
+void view_resize(View* view, size_t width, size_t nrows)
+{
     require(view != NULL);
     require(width > 0);
     require(nrows > 0);
     if (view->width == width && view->nvisible == nrows)
+    {
         return;
+    }
     size_t off = (view->nrows && view->index < view->nrows ? view->rows[view->index]->off : 0);
     resize(view, width, nrows, off);
     ensure(view_valid(view));
 }
 
-void view_update(View* view) {
+void view_update(View* view)
+{
     require(view != NULL);
     /* refill the view contents to make sure updates are visible */
     size_t off = view->rows[view->index]->off;
     clear_rows(view, view->index);
     for (size_t i = 0; i < view->nvisible; i++)
+    {
         off = add_row(view, off);
+    }
     /* sync up the view with the cursor */
-    if (view->sync_flags) {
-        if (view->sync_flags & CENTER) {
+    if (view->sync_flags)
+    {
+        if (view->sync_flags & CENTER)
+        {
             resize(view, view->width, view->nrows, CSRPOS);
             view_scroll(view, UP * (view->nvisible/2));
-        } else {
+        }
+        else
+        {
             Row* lastrow = view->rows[view->nrows-1];
             size_t last_off = lastrow->cols[lastrow->len-1].off;
             view_scrollto(view, CSRPOS);
             if (last_off < CSRPOS)
+            {
                 view_scroll(view, UP * (view->nvisible-1));
+            }
         }
         view->sync_flags = 0;
     }
     ensure(view_valid(view));
 }
 
-Row* view_getrow(View* view, size_t row) {
+Row* view_getrow(View* view, size_t row)
+{
     return (row < view->nrows ? view->rows[row] : NULL);
 }
 
-void view_byrune(View* view, int move, bool extsel) {
+void view_byrune(View* view, int move, bool extsel)
+{
     require(view != NULL);
     move_selection(view, extsel, move, buf_byrune);
     ensure(view_valid(view));
 }
 
-void view_byword(View* view, int move, bool extsel) {
+void view_byword(View* view, int move, bool extsel)
+{
     require(view != NULL);
     move_selection(view, extsel, move, buf_byword);
     ensure(view_valid(view));
 }
 
-void view_byline(View* view, int move, bool extsel) {
+void view_byline(View* view, int move, bool extsel)
+{
     require(view != NULL);
     move_selection(view, extsel, move, buf_byline);
     ensure(view_valid(view));
 }
 
-static size_t getoffset(View* view, size_t row, size_t col) {
+static size_t getoffset(View* view, size_t row, size_t col)
+{
     size_t i = 0, y = 0, idx = view->index + row;
     if (idx >= view->nrows) return 0;
     Row* selrow = view->rows[idx];
-    for (; i < selrow->len; i++) {
+    for (; i < selrow->len; i++)
+    {
         y += selrow->cols[i].width;
-        if (col < y) break;
+        if (col < y)
+        {
+            break;
+        }
     }
     return selrow->cols[i].off;
 }
 
-void view_setcursor(View* view, size_t row, size_t col, bool extsel) {
+void view_setcursor(View* view, size_t row, size_t col, bool extsel)
+{
     getsel(view)->end = getoffset(view, row, col);
     if (!extsel)
+    {
         getsel(view)->beg = getsel(view)->end;
+    }
     buf_getcol(BUF);
     ensure(view_valid(view));
 }
 
-void view_selword(View* view, size_t row, size_t col) {
+void view_selword(View* view, size_t row, size_t col)
+{
     if (row != SIZE_MAX && col != SIZE_MAX)
+    {
         view_setcursor(view, row, col, false);
+    }
     buf_selword(BUF, risbigword);
     ensure(view_valid(view));
 }
 
-void view_selprev(View* view) {
+void view_selprev(View* view)
+{
     if (!view_selsize(view))
+    {
         buf_lastins(BUF);
+    }
     else
+    {
         buf_selclr(BUF, RIGHT);
+    }
     ensure(view_valid(view));
 }
 
-void view_select(View* view, size_t row, size_t col) {
+void view_select(View* view, size_t row, size_t col)
+{
     view_setcursor(view, row, col, false);
     buf_selctx(BUF, risword);
     ensure(view_valid(view));
 }
 
-size_t view_selsize(View* view) {
+size_t view_selsize(View* view)
+{
     return buf_selsz(BUF);
 }
 
-char* view_fetch(View* view, size_t row, size_t col, bool (*isword)(Rune)) {
+char* view_fetch(View* view, size_t row, size_t col, bool (*isword)(Rune))
+{
     char* str = NULL;
     size_t off = getoffset(view, row, col);
     if (off != SIZE_MAX)
+    {
         str = buf_fetch(BUF, isword, off);
+    }
     ensure(view_valid(view));
     return str;
 }
 
-bool view_findstr(View* view, int dir, char* str) {
+bool view_findstr(View* view, int dir, char* str)
+{
     bool found = buf_findstr(BUF, dir, str);
     view->sync_flags |= (CURSOR|CENTER);
     ensure(view_valid(view));
     return found;
 }
 
-void view_insert(View* view, Rune rune) {
+void view_insert(View* view, Rune rune)
+{
     /* ignore non-printable control characters */
     if (!isspace(rune) && (rune >= 0 && rune < 0x20))
+    {
         return;
-    if (ExpandTabs && rune == '\t') {
+    }
+    if (ExpandTabs && rune == '\t')
+    {
         size_t off = buf_selbeg(BUF);
         size_t n = (TabWidth - ((off - buf_bol(BUF, off)) % TabWidth));
         for (; n > 0; n--) buf_putc(BUF, ' ');
-    } else if (CopyIndent && rune == '\n') {
+    }
+    else if (CopyIndent && rune == '\n')
+    {
         size_t off = buf_selbeg(BUF);
         size_t beg = buf_bol(BUF, off), end = beg;
-        for (; end < buf_end(BUF) && end < off && (' ' == buf_getrat(BUF, end) || '\t' == buf_getrat(BUF, end)); end++);
+        for (; end < buf_end(BUF) && end < off && (' ' == buf_getrat(BUF, end) || '\t' == buf_getrat(BUF, end)); end++)
+        {
+        }
         char* str = buf_getsat(BUF, beg, end);
         buf_putc(BUF, '\n');
         buf_puts(BUF, str);
         free(str);
-    } else {
+    }
+    else
+    {
         buf_putc(BUF, rune);
     }
     move_to(view, false, CSRPOS);
     ensure(view_valid(view));
 }
 
-void view_delete(View* view, int dir, bool byword) {
+void view_delete(View* view, int dir, bool byword)
+{
     if (!view_selsize(view))
+    {
         (byword ? view_byword : view_byrune)(view, dir, true);
+    }
     buf_del(BUF);
     move_to(view, false, CSRPOS);
     ensure(view_valid(view));
 }
 
-void view_jumpto(View* view, bool extsel, size_t off) {
+void view_jumpto(View* view, bool extsel, size_t off)
+{
     move_to(view, extsel, off);
     ensure(view_valid(view));
 }
 
-void view_bol(View* view, bool extsel) {
+void view_bol(View* view, bool extsel)
+{
     /* determine whether we are jumping to start of content or line */
     Buf* buf = BUF;
     unsigned bol = buf_bol(buf, CSRPOS);
@@ -358,46 +480,60 @@ void view_bol(View* view, bool extsel) {
     ensure(view_valid(view));
 }
 
-void view_eol(View* view, bool extsel) {
+void view_eol(View* view, bool extsel)
+{
     move_to(view, extsel, buf_eol(BUF, CSRPOS));
     getsel(view)->col = -1; // Peg cursor to line end
     ensure(view_valid(view));
 }
 
-void view_bof(View* view, bool extsel) {
+void view_bof(View* view, bool extsel)
+{
     view_jumpto(view, extsel, 0);
     ensure(view_valid(view));
 }
 
-void view_eof(View* view, bool extsel) {
+void view_eof(View* view, bool extsel)
+{
     view_jumpto(view, extsel, buf_end(BUF));
     ensure(view_valid(view));
 }
 
-void view_setln(View* view, size_t line) {
+void view_setln(View* view, size_t line)
+{
     view->sync_flags |= CENTER;
-    if (line) {
+    if (line)
+    {
         buf_setln(BUF, line);
         buf_selln(BUF);
     }
     ensure(view_valid(view));
 }
 
-void view_undo(View* view) {
+void view_undo(View* view)
+{
     buf_undo(BUF);
     view->sync_flags |= CURSOR;
-    if (!selection_visible(view)) view->sync_flags |= CENTER;
+    if (!selection_visible(view))
+    {
+        view->sync_flags |= CENTER;
+    }
     ensure(view_valid(view));
 }
 
-void view_redo(View* view) {
+void view_redo(View* view)
+{
     buf_redo(BUF);
     view->sync_flags |= CURSOR;
-    if (!selection_visible(view)) view->sync_flags |= CENTER;
+    if (!selection_visible(view))
+    {
+        view->sync_flags |= CENTER;
+    }
     ensure(view_valid(view));
 }
 
-void view_paste(View* view, char* str) {
+void view_paste(View* view, char* str)
+{
     buf_logstart(BUF);
     view_putstr(view, str);
     buf_logstop(BUF);
@@ -405,90 +541,124 @@ void view_paste(View* view, char* str) {
     ensure(view_valid(view));
 }
 
-void view_putstr(View* view, char* str) {
+void view_putstr(View* view, char* str)
+{
     buf_puts(BUF, str);
     ensure(view_valid(view));
 }
 
-char* view_getstr(View* view) {
+char* view_getstr(View* view)
+{
     return buf_gets(BUF);
 }
 
-char* view_getcmd(View* view) {
+char* view_getcmd(View* view)
+{
     if (!view_selsize(view))
+    {
         buf_selctx(BUF, riscmd);
+    }
     ensure(view_valid(view));
     return view_getstr(view);
 }
 
-void view_selctx(View* view) {
+void view_selctx(View* view)
+{
     if (!view_selsize(view))
+    {
         buf_selctx(BUF, risword);
+    }
     ensure(view_valid(view));
 }
 
-char* view_getctx(View* view) {
+char* view_getctx(View* view)
+{
     view_selctx(view);
     ensure(view_valid(view));
     return view_getstr(view);
 }
 
-static void scroll_up(View* view) {
+static void scroll_up(View* view)
+{
     if (view->index > 0)
+    {
         view->index--;
+    }
     else if (view->rows[0]->off > 0)
+    {
         resize(view, view->width, view->nvisible, buf_byrune(BUF, view->rows[0]->off, LEFT));
+    }
 }
 
-static void scroll_dn(View* view) {
-    if (view->nrows <= 1) return;
+static void scroll_dn(View* view)
+{
+    if (view->nrows <= 1)
+    {
+        return;
+    }
     size_t nleft = (view->nrows - view->index);
-    if (nleft <= view->nvisible) {
+    if (nleft <= view->nvisible)
+    {
         size_t off = view->rows[view->index+1]->off;
         resize(view, view->width, view->nvisible, off);
-    } else {
+    }
+    else
+    {
         view->index++;
     }
 }
 
-void view_scroll(View* view, int move) {
+void view_scroll(View* view, int move)
+{
     int dir = (move < 0 ? -1 : 1);
     move *= dir;
-    for (int i = 0; i < move; i++) {
+    for (int i = 0; i < move; i++)
+    {
         if (dir < 0)
+        {
             scroll_up(view);
+        }
         else
+        {
             scroll_dn(view);
+        }
     }
     ensure(view_valid(view));
 }
 
-void view_scrollpage(View* view, int move) {
+void view_scrollpage(View* view, int move)
+{
     move = (move < 0 ? -1 : 1) * view->nrows;
     view_scroll(view, move);
     ensure(view_valid(view));
 }
 
-Rune view_getrune(View* view) {
+Rune view_getrune(View* view)
+{
     return buf_getc(BUF);
 }
 
-void view_scrollto(View* view, size_t csr) {
+void view_scrollto(View* view, size_t csr)
+{
     Row* lastrow = view->rows[view->nrows-1];
     size_t first = view->rows[view->index]->off;
     size_t last  = lastrow->cols[lastrow->len-1].off;
     if (csr < first || csr > last)
+    {
         resize(view, view->width, view->nrows, csr);
+    }
     ensure(view_valid(view));
 }
 
-void view_selectall(View* view) {
+void view_selectall(View* view)
+{
     buf_selall(BUF);
     view->sync_flags |= CURSOR;
     ensure(view_valid(view));
 }
 
-void view_selectobj(View* view, bool (*istype)(Rune)) {
+void view_selectobj(View* view, bool (*istype)(Rune))
+{
     buf_selword(BUF, istype);
     view->sync_flags |= CURSOR;
     ensure(view_valid(view));