Refactoring: some vars moved into pwstate struct.

The variables that are being passed around are moved into
an object, to reduce the number of parameters being passed
around.

1 files changed, 201 insertions, 196 deletions

diff --git a/pw.c b/pw.c
index f25a414..fb7590f 100644
--- a/pw.c
+++ b/pw.c
@@ -61,6 +61,11 @@
 #define printf_attr(fmtpos, vargpos)
 #endif
 
+#define cmdsize 256
+#define maxgrep 64
+#define maxtrig 100
+#define snhistsize 20
+
 enum status_flags {
   stat_dirty = 1,   // display needs refresh
   stat_eof = 2,     // end of data reached
@@ -74,6 +79,17 @@ enum status_flags {
   stat_bkgnd = 512  // running in the background
 };
 
+typedef struct pwstate {
+  char **circbuf;
+  int nlines;
+  unsigned hpos;
+  unsigned hist;
+  int columns;
+  unsigned stat;
+  char *curcmd, *savedcmd;
+  char cmdbuf[cmdsize];
+} pwstate;
+
 typedef struct grep {
   char *pat;
   regex_t rx;
@@ -82,11 +98,6 @@ typedef struct grep {
   void (*dtor)(char *);
 } grep;
 
-#define cmdsize 256
-#define maxgrep 64
-#define maxtrig 100
-#define snhistsize 20
-
 typedef struct dstr {
   int refs;
   size_t len;
@@ -325,17 +336,18 @@ static void clreol(int nl)
     putchar('\n');
 }
 
-static void drawline(const char *line, unsigned hpos, int columns, int lineno)
+static void drawline(pwstate *pw, const char *line, int lineno)
 {
   size_t len = dslen(line);
+  int columns = pw->columns;
 
   if (lineno >= 0)
     columns -= printf("%3d ", lineno);
 
-  if ((size_t) hpos <= len) {
-    if (hpos) {
-      line += hpos;
-      len -= hpos;
+  if ((size_t) pw->hpos <= len) {
+    if (pw->hpos) {
+      line += pw->hpos;
+      len -= pw->hpos;
       putchar('>');
       columns--;
     }
@@ -353,32 +365,32 @@ static void drawline(const char *line, unsigned hpos, int columns, int lineno)
   }
 }
 
-static void drawstatus(unsigned hist, int columns, unsigned stat, char *cmd)
+static void drawstatus(pwstate *pw)
 {
   char status[cmdsize] = "", *ptr = status;
   size_t lim = sizeof status;
 
-  if ((stat & stat_bkgnd))
+  if ((pw->stat & stat_bkgnd))
     return;
 
-  if (columns - 1 < (int) lim)
-    lim = columns - 1;
+  if (pw->columns - 1 < (int) lim)
+    lim = pw->columns - 1;
 
   char *end = ptr + lim;
 
-  if (cmd) {
-    snprintf(status, lim, "%s", cmd);
-  } else if (hist > 0 ||
-             (stat & (stat_eof | stat_susp | stat_htmode | stat_ttmode |
-                      stat_grep)))
+  if (pw->curcmd) {
+    snprintf(status, lim, "%s", pw->curcmd);
+  } else if (pw->hist > 0 ||
+             (pw->stat & (stat_eof | stat_susp | stat_htmode | stat_ttmode |
+                          stat_grep)))
   {
-    if (hist > 0)
-      ptr += snprintf(ptr, end - ptr, "HIST%u ", hist);
+    if (pw->hist > 0)
+      ptr += snprintf(ptr, end - ptr, "HIST%u ", pw->hist);
 
-    if ((stat & stat_eof))
+    if ((pw->stat & stat_eof))
       ptr += snprintf(ptr, end - ptr, "EOF ");
 
-    if ((stat & stat_grep)) {
+    if ((pw->stat & stat_grep)) {
       ptr += snprintf(ptr, end - ptr, "GREP (");
       for (int i = 0; i < ngrep; i++) {
         grep *gr = &grepstack[i];
@@ -388,9 +400,9 @@ static void drawstatus(unsigned hist, int columns, unsigned stat, char *cmd)
       }
     }
 
-    if ((stat & (stat_htmode | stat_ttmode))) {
+    if ((pw->stat & (stat_htmode | stat_ttmode))) {
       ptr += snprintf(ptr, end - ptr, "TRIG%c (",
-                      (stat & stat_htmode) ? '/' : '?');
+                      (pw->stat & stat_htmode) ? '/' : '?');
       for (int i = 0, first = 1; i < maxtrig; i++) {
         grep *gr = triglist[i];
         if (gr) {
@@ -405,7 +417,7 @@ static void drawstatus(unsigned hist, int columns, unsigned stat, char *cmd)
       ptr += snprintf(ptr, end - ptr, ") ");
     }
 
-    if ((stat & stat_susp))
+    if ((pw->stat & stat_susp))
       ptr += snprintf(ptr, end - ptr, "SUSPENDED ");
   }
 
@@ -421,14 +433,13 @@ static void freebuf(char **buf, size_t size)
       dsdrop(buf[i]);
 }
 
-static unsigned redraw(char **circbuf, int nlines, unsigned hpos, unsigned hist,
-                       int columns, unsigned stat, char *cmd)
+static void redraw(pwstate *pw)
 {
   int updln = 0;
 
-  if ((stat & (stat_dirty | stat_susp)) == stat_dirty &&
-      (stat & (stat_htmode | stat_trgrd)) != stat_htmode &&
-      (stat & (stat_ttmode | stat_trgrd)) != stat_ttmode)
+  if ((pw->stat & (stat_dirty | stat_susp)) == stat_dirty &&
+      (pw->stat & (stat_htmode | stat_trgrd)) != stat_htmode &&
+      (pw->stat & (stat_ttmode | stat_trgrd)) != stat_ttmode)
   {
     if (snapshot[snhistsize - 1]) {
       freebuf(snapshot[snhistsize - 1], snaplines[snhistsize - 1]);
@@ -436,42 +447,40 @@ static unsigned redraw(char **circbuf, int nlines, unsigned hpos, unsigned hist,
     }
     memmove(snapshot + 1, snapshot, sizeof *snapshot * (snhistsize - 1));
     memmove(snaplines + 1, snaplines, sizeof *snaplines * (snhistsize - 1));
-    snapshot[0] = calloc(sizeof *snapshot[0], nlines);
-    snaplines[0] = nlines;
+    snapshot[0] = calloc(sizeof *snapshot[0], pw->nlines);
+    snaplines[0] = pw->nlines;
     updln = 1;
-    for (int i = 0; i < nlines; i++)
-      snapshot[0][i] = dsref(circbuf[i]);
-    stat &= ~(stat_dirty | stat_trgrd);
+    for (int i = 0; i < pw->nlines; i++)
+      snapshot[0][i] = dsref(pw->circbuf[i]);
+    pw->stat &= ~(stat_dirty | stat_trgrd);
     updln = 1;
-  } else if ((stat & stat_force)) {
-    stat &= ~stat_force;
+  } else if ((pw->stat & stat_force)) {
+    pw->stat &= ~stat_force;
     updln = 1;
   }
 
-  if ((stat & stat_bkgnd))
-    return stat;
+  if ((pw->stat & stat_bkgnd))
+    return;
 
-  if (updln && snaplines[hist] > 0) {
-    printf("\r\033[%dA", snaplines[hist]);
-    if ((stat & stat_lino) == 0) {
-      for (int i = 0; i < snaplines[hist]; i++)
-        drawline(snapshot[hist][i], hpos, columns, -1);
+  if (updln && snaplines[pw->hist] > 0) {
+    printf("\r\033[%dA", snaplines[pw->hist]);
+    if ((pw->stat & stat_lino) == 0) {
+      for (int i = 0; i < snaplines[pw->hist]; i++)
+        drawline(pw, snapshot[pw->hist][i], -1);
     } else {
       int start = 1, step = 1;
-      if (stat & stat_htmode) {
-        start = snaplines[hist];
+      if (pw->stat & stat_htmode) {
+        start = snaplines[pw->hist];
         step = -1;
       }
-      for (int i = 0, l = start; i < snaplines[hist]; i++, l += step)
-        drawline(snapshot[hist][i], hpos, columns, l);
+      for (int i = 0, l = start; i < snaplines[pw->hist]; i++, l += step)
+        drawline(pw, snapshot[pw->hist][i], l);
     }
   } else {
-    clrline(stat);
+    clrline(pw->stat);
   }
 
-  drawstatus(hist, columns, stat, cmd);
-
-  return stat;
+  drawstatus(pw);
 }
 
 static int getzp(const char *str, char **err)
@@ -528,7 +537,7 @@ static int getms(const char *str, char **err)
   return msec;
 }
 
-static void execute(char *cmd, unsigned *pstat, unsigned hist)
+static void execute(pwstate *pw, char *cmd)
 {
   char *arg = cmd + 2 + strspn(cmd + 2, " \t");
 
@@ -549,8 +558,8 @@ static void execute(char *cmd, unsigned *pstat, unsigned hist)
         break;
       }
 
-      for (int i = 0; ok && i < snaplines[hist]; i++)
-        if (fprintf(f, "%s\n", snapshot[hist][i]) < 0) {
+      for (int i = 0; ok && i < snaplines[pw->hist]; i++)
+        if (fprintf(f, "%s\n", snapshot[pw->hist][i]) < 0) {
           sprintf(cmd, "write error!");
           ok = 0;
           break;
@@ -575,8 +584,8 @@ static void execute(char *cmd, unsigned *pstat, unsigned hist)
         break;
       }
 
-      for (int i = 0; i < snaplines[hist] && ok; i++)
-        if (fprintf(p, "%s\n", snapshot[hist][i]) < 0) {
+      for (int i = 0; i < snaplines[pw->hist] && ok; i++)
+        if (fprintf(p, "%s\n", snapshot[pw->hist][i]) < 0) {
           sprintf(cmd, "write error!");
           ok = 0;
           break;
@@ -609,7 +618,7 @@ static void execute(char *cmd, unsigned *pstat, unsigned hist)
       }
 
       if (ngrep++ == 0)
-        *pstat |= stat_grep;
+        pw->stat |= stat_grep;
     }
     break;
   case 'r':
@@ -621,7 +630,7 @@ static void execute(char *cmd, unsigned *pstat, unsigned hist)
         break;
     }
     if (ngrep == 0)
-      *pstat &= ~stat_grep;
+      pw->stat &= ~stat_grep;
     break;
   case 'i': case 'l':
     {
@@ -692,18 +701,16 @@ int isbkgnd(FILE *tty)
 
 int main(int argc, char **argv)
 {
+  struct pwstate pw = { .columns = 80 };
   char *line = 0;
-  unsigned stat = 0;
   FILE *tty = fopen("/dev/tty", "r+");
-  int maxlines = 15, nlines = 0, maxed = 0;
+  int maxlines = 15, maxed = 0;
   size_t maxlen = 2047;
   int opt;
   int ifd = fileno(stdin);
   int ttyfd = tty ? fileno(tty) : -1;
-  char **circbuf;
   struct termios tty_saved, tty_new;
   struct winsize ws = { 0 };
-  int columns = 80;
   enum kbd_state {
     kbd_cmd, kbd_esc, kbd_bkt, kbd_exit,
     kbd_colon, kbd_result, kbd_trig
@@ -711,7 +718,6 @@ int main(int argc, char **argv)
   int auto_quit = 1;
   int quit_count = 1, quit_countdown = quit_count;
   int exit_status = EXIT_FAILURE;
-  char cmdbuf[cmdsize], *curcmd = 0, *savedcmd = 0;
 #ifdef SIGWINCH
   static struct sigaction sa;
 #endif
@@ -805,7 +811,7 @@ int main(int argc, char **argv)
         }
 
         ngrep++;
-        stat |= stat_grep;
+        pw.stat |= stat_grep;
       }
       break;
     case 'm':
@@ -832,7 +838,7 @@ int main(int argc, char **argv)
     return EXIT_FAILURE;
   }
 
-  if ((circbuf = calloc(sizeof *circbuf, maxlines)) == 0)
+  if ((pw.circbuf = calloc(sizeof *pw.circbuf, maxlines)) == 0)
     panic("out of memory");
   if ((snapshot[0] = calloc(sizeof *snapshot[0], maxlines)) == 0)
     panic("out of memory");
@@ -842,7 +848,7 @@ int main(int argc, char **argv)
       maxlines = ws.ws_row - 1;
       maxed = 1;
     }
-    columns = ws.ws_col;
+    pw.columns = ws.ws_col;
   }
 
   ttyget(ttyfd, &tty_saved);
@@ -864,15 +870,14 @@ int main(int argc, char **argv)
   if (!isbkgnd(stdout))
     ttyset(ttyfd, &tty_new);
   else
-    stat = stat_bkgnd;
+    pw.stat = stat_bkgnd;
 
 #ifdef SIGWINCH
   sa.sa_handler = sigwinch;
   sigaction(SIGWINCH, &sa, NULL);
 #endif
 
-  for (unsigned hpos = 0, hist = 0,
-                kbd_state = kbd_cmd, kbd_prev = kbd_cmd, lasttime = ~0U,
+  for (unsigned kbd_state = kbd_cmd, kbd_prev = kbd_cmd, lasttime = ~0U,
                 workbout = 1024, work = workbout, histpos = 0,
                 cmdcount = UINT_MAX;
        kbd_state != kbd_exit ;)
@@ -883,7 +888,7 @@ int main(int argc, char **argv)
       { .fd = ifd, .events = POLLIN | POLLHUP | POLLERR },
     };
 
-    if ((stat & stat_eof) == 0) {
+    if ((pw.stat & stat_eof) == 0) {
       int ch;
       while ((ch = getc(stdin)) != EOF && ch != '\n' && dslen(line) < maxlen)
         line = addchesc(line, ch);
@@ -893,19 +898,19 @@ int main(int argc, char **argv)
           if (!ferror(stdin))
             exit_status = 0;
           if (auto_quit) {
-            if ((stat & stat_bkgnd) == 0)
-              clrline(stat);
+            if ((pw.stat & stat_bkgnd) == 0)
+              clrline(pw.stat);
             break;
           }
-          stat |= stat_eof;
-          clrline(stat);
-          drawstatus(hist, columns, stat, curcmd);
+          pw.stat |= stat_eof;
+          clrline(pw.stat);
+          drawstatus(&pw);
         }
         clearerr(stdin);
       } else if (ch == '\n') {
         nfds = 1;
         line = addch(line, 0);
-        if ((stat & stat_grep)) {
+        if ((pw.stat & stat_grep)) {
           int i;
           for (i = 0; i < ngrep; i++)
             if (!grexec(&grepstack[i], line))
@@ -916,43 +921,43 @@ int main(int argc, char **argv)
           }
         }
         if (line) {
-          if (nlines == maxlines) {
-            dsdrop(circbuf[0]);
-            memmove(circbuf, circbuf + 1, (nlines - 1) * sizeof *circbuf);
-            circbuf[nlines - 1] = line;
-            stat |= stat_dirty;
-            if ((stat & stat_ttmode)) {
-              int lim = min(maxtrig, nlines);
+          if (pw.nlines == maxlines) {
+            dsdrop(pw.circbuf[0]);
+            memmove(pw.circbuf, pw.circbuf + 1, (pw.nlines - 1) * sizeof *pw.circbuf);
+            pw.circbuf[pw.nlines - 1] = line;
+            pw.stat |= stat_dirty;
+            if ((pw.stat & stat_ttmode)) {
+              int lim = min(maxtrig, pw.nlines);
               int trig = 1;
               for (int i = 0; i < lim; i++) {
                 grep *gr = triglist[i];
-                if (gr && !grexec(gr, circbuf[i])) {
+                if (gr && !grexec(gr, pw.circbuf[i])) {
                   trig = 0;
                   break;
                 }
               }
               if (trig)
-                stat |= stat_trgrd;
-            } else if ((stat & stat_htmode)) {
+                pw.stat |= stat_trgrd;
+            } else if ((pw.stat & stat_htmode)) {
               int trig = 1;
-              for (int j = nlines - 1, i = 0; j >= 0 && i < maxtrig; j--, i++) {
+              for (int j = pw.nlines - 1, i = 0; j >= 0 && i < maxtrig; j--, i++) {
                 grep *gr = triglist[i];
-                if (gr && !grexec(gr, circbuf[j])) {
+                if (gr && !grexec(gr, pw.circbuf[j])) {
                   trig = 0;
                   break;
                 }
               }
               if (trig)
-                stat |= stat_trgrd;
+                pw.stat |= stat_trgrd;
             }
           } else {
-            circbuf[nlines++] = line;
-            if ((stat & (stat_susp | stat_bkgnd)) == 0) {
+            pw.circbuf[pw.nlines++] = line;
+            if ((pw.stat & (stat_susp | stat_bkgnd)) == 0) {
               snapshot[0] = resizebuf(snapshot[0], snaplines[0], snaplines[0] + 1);
               snapshot[0][snaplines[0]++] = dsref(line);
-              clrline(stat);
-              drawline(line, hpos, columns, (stat & stat_lino) ? 0: -1);
-              drawstatus(hist, columns, stat, curcmd);
+              clrline(pw.stat);
+              drawline(&pw, line, (pw.stat & stat_lino) ? 0: -1);
+              drawstatus(&pw);
             }
           }
           line = 0;
@@ -966,8 +971,8 @@ int main(int argc, char **argv)
       winch = 0;
       if (ioctl(ttyfd, TIOCGWINSZ, &ws) == 0) {
         if (maxed) {
-          hist = 0;
-          circbuf = resizebuf(circbuf, maxlines, ws.ws_row - 1);
+          pw.hist = 0;
+          pw.circbuf = resizebuf(pw.circbuf, maxlines, ws.ws_row - 1);
           snapshot[0] = resizebuf(snapshot[0], maxlines, ws.ws_row - 1);
           for (int i = 1; i < snhistsize; i++) {
             freebuf(snapshot[i], snaplines[i]);
@@ -981,23 +986,23 @@ int main(int argc, char **argv)
           }
         }
 
-        if (nlines > maxlines)
-          nlines = maxlines;
+        if (pw.nlines > maxlines)
+          pw.nlines = maxlines;
         if (snaplines[0] > maxlines)
           snaplines[0] = maxlines;
 
-        columns = ws.ws_col;
+        pw.columns = ws.ws_col;
       }
-      stat |= stat_force;
+      pw.stat |= stat_force;
       force = 1;
     }
 
-    if ((stat & stat_eof))
+    if ((pw.stat & stat_eof))
       pollms = -1;
     else if (nfds < 2)
       pollms = 0;
 
-    if ((stat & (stat_trgrd | stat_susp)) == stat_trgrd)
+    if ((pw.stat & (stat_trgrd | stat_susp)) == stat_trgrd)
       force = 1;
 
     if (pollms == 0 && !force && work-- > 0)
@@ -1005,16 +1010,16 @@ int main(int argc, char **argv)
 
     work = workbout;
 
-    if ((stat & stat_bkgnd)) {
+    if ((pw.stat & stat_bkgnd)) {
       if (!isbkgnd(stdout)) {
-        stat &= ~stat_bkgnd;
+        pw.stat &= ~stat_bkgnd;
         ttyset(ttyfd, &tty_new);
-        for (int i = 0; i < nlines; i++)
+        for (int i = 0; i < pw.nlines; i++)
           puts("");
-        stat = redraw(circbuf, nlines, hpos, hist, columns,
-                      stat | stat_force, curcmd);
+        pw.stat |= force;
+        redraw(&pw);
       } else {
-        if ((stat & stat_eof)) {
+        if ((pw.stat & stat_eof)) {
           sleep(1);
           continue;
         } else {
@@ -1023,7 +1028,7 @@ int main(int argc, char **argv)
       }
     }
 
-    if ((stat & (stat_bkgnd | stat_susp)) == 0) {
+    if ((pw.stat & (stat_bkgnd | stat_susp)) == 0) {
       if (!force) {
         struct timeval tv;
         unsigned now;
@@ -1031,25 +1036,25 @@ int main(int argc, char **argv)
         gettimeofday(&tv, NULL);
         now = (((unsigned) tv.tv_sec)%1000000)*1000 + tv.tv_usec/1000;
         if (lasttime == ~0U || now - lasttime > (unsigned) long_interval) {
-          if ((stat & stat_dirty) && nlines == maxlines)
+          if ((pw.stat & stat_dirty) && pw.nlines == maxlines)
             force = 1;
           lasttime = now;
         }
       }
 
       if (force)
-        stat = redraw(circbuf, nlines, hpos, hist, columns, stat, curcmd);
+        redraw(&pw);
     }
 
     if (poll(pe, nfds, pollms) <= 0) {
       if (pollms) {
-        if ((stat & stat_dirty) && nlines == maxlines)
-          stat = redraw(circbuf, nlines, hpos, hist, columns, stat, curcmd);
+        if ((pw.stat & stat_dirty) && pw.nlines == maxlines)
+          redraw(&pw);
         if (kbd_state == kbd_esc || kbd_state == kbd_result) {
           kbd_state = kbd_cmd;
-          curcmd = 0;
-          clrline(stat);
-          drawstatus(hist, columns, stat, curcmd);
+          pw.curcmd = 0;
+          clrline(pw.stat);
+          drawstatus(&pw);
         }
       }
       work = workbout += workbout / 4;
@@ -1062,7 +1067,7 @@ int main(int argc, char **argv)
 
         if (ch == ctrl('z')) {
           ttyset(ttyfd, &tty_saved);
-          stat |= stat_bkgnd;
+          pw.stat |= stat_bkgnd;
           kill(0, SIGTSTP);
           continue;
         }
@@ -1071,8 +1076,8 @@ int main(int argc, char **argv)
         switch (kbd_state) {
         case kbd_result:
           kbd_state = kbd_cmd;
-          stat |= stat_force;
-          curcmd = 0;
+          pw.stat |= stat_force;
+          pw.curcmd = 0;
           // fallthrough
         case kbd_cmd:
           if (ch != 'q' && ch != 3)
@@ -1082,41 +1087,41 @@ int main(int argc, char **argv)
             if (--quit_countdown == 0) {
               kbd_state = kbd_exit;
             } else {
-              sprintf(cmdbuf, "%d more to quit", quit_countdown);
-              curcmd = cmdbuf;
+              sprintf(pw.cmdbuf, "%d more to quit", quit_countdown);
+              pw.curcmd = pw.cmdbuf;
               kbd_state = kbd_result;
             }
             break;
           case 'h':
-            if (hpos >= 8) {
-              hpos -= 8;
-              stat |= stat_force;
+            if (pw.hpos >= 8) {
+              pw.hpos -= 8;
+              pw.stat |= stat_force;
             }
             break;
           case 'l':
-            if (hpos < 10000) {
-              hpos += 8;
-              stat |= stat_force;
+            if (pw.hpos < 10000) {
+              pw.hpos += 8;
+              pw.stat |= stat_force;
             }
             break;
           case 'j':
-            if (hist > 0) {
-              hist--;
-              stat |= stat_force;
+            if (pw.hist > 0) {
+              pw.hist--;
+              pw.stat |= stat_force;
             }
             break;
           case 'k':
-            if (hist < snhistsize - 1 && snapshot[hist + 1]) {
-              hist++;
-              stat |= stat_force;
+            if (pw.hist < snhistsize - 1 && snapshot[pw.hist + 1]) {
+              pw.hist++;
+              pw.stat |= stat_force;
             }
             break;
           case ' ':
-            if ((stat & stat_eof) == 0)
-              stat |= stat_susp;
+            if ((pw.stat & stat_eof) == 0)
+              pw.stat |= stat_susp;
             break;
           case CR:
-            stat &= ~stat_susp;
+            pw.stat &= ~stat_susp;
             break;
           case ESC:
             kbd_prev = kbd_state;
@@ -1125,21 +1130,21 @@ int main(int argc, char **argv)
           case ':':
             kbd_state = kbd_colon;
             histpos = 0;
-            cmdbuf[0] = ch;
-            cmdbuf[1] = 0;
-            curcmd = cmdbuf;
+            pw.cmdbuf[0] = ch;
+            pw.cmdbuf[1] = 0;
+            pw.curcmd = pw.cmdbuf;
             break;
           case '/': case '?':
             kbd_state = kbd_trig;
             histpos = 0;
-            cmdbuf[0] = ch;
-            cmdbuf[1] = 0;
-            curcmd = cmdbuf;
+            pw.cmdbuf[0] = ch;
+            pw.cmdbuf[1] = 0;
+            pw.curcmd = pw.cmdbuf;
             break;
           case 'a': case 'd':
-            if ((stat & (stat_htmode | stat_ttmode))) {
-              int step = ((((stat & stat_htmode) && ch == 'a') ||
-                           ((stat & stat_ttmode) && ch == 'd'))
+            if ((pw.stat & (stat_htmode | stat_ttmode))) {
+              int step = ((((pw.stat & stat_htmode) && ch == 'a') ||
+                           ((pw.stat & stat_ttmode) && ch == 'd'))
                           ? -1 : 1);
 
               if (cmdcount == UINT_MAX)
@@ -1151,9 +1156,9 @@ int main(int argc, char **argv)
                           (maxtrig - 1) * sizeof *triglist);
                   triglist[maxtrig - 1] = 0;
                 }
-              } else if (nlines <= maxtrig) {
+              } else if (pw.nlines <= maxtrig) {
                 for (; (cmdcount &&
-                        !triglist[nlines - 1] &&
+                        !triglist[pw.nlines - 1] &&
                         !triglist[maxtrig - 1]);
                      cmdcount --)
                 {
@@ -1165,7 +1170,7 @@ int main(int argc, char **argv)
             }
             break;
           case '+':
-            if (hist > 0 || (ws.ws_row && maxlines >= ws.ws_row - 1)) {
+            if (pw.hist > 0 || (ws.ws_row && maxlines >= ws.ws_row - 1)) {
               break;
             } else {
               unsigned count = (cmdcount == UINT_MAX) ? 1 : cmdcount;
@@ -1177,7 +1182,7 @@ int main(int argc, char **argv)
                 maxlines = ws.ws_row - 1;
               }
 
-              circbuf = resizebuf(circbuf, maxlines, maxlines + 1);
+              pw.circbuf = resizebuf(pw.circbuf, maxlines, maxlines + 1);
               snapshot[0] = resizebuf(snapshot[0], maxlines, maxlines + 1);
               for (int i = 1; i < snhistsize; i++) {
                 freebuf(snapshot[i], snaplines[i]);
@@ -1187,15 +1192,15 @@ int main(int argc, char **argv)
             }
             break;
           case '#':
-            stat ^= stat_lino;
+            pw.stat ^= stat_lino;
             // fallthrough
           case ctrl('l'):
-            stat |= stat_force;
+            pw.stat |= stat_force;
             break;
           case '0':
             if (cmdcount == UINT_MAX) {
-              hpos = 0;
-              stat |= stat_force;
+              pw.hpos = 0;
+              pw.stat |= stat_force;
               break;
             }
             // fallthrough
@@ -1215,7 +1220,7 @@ int main(int argc, char **argv)
             break;
           }
           kbd_state = kbd_cmd;
-          curcmd = 0;
+          pw.curcmd = 0;
           break;
         case kbd_bkt:
           kbd_state = kbd_prev;
@@ -1256,30 +1261,30 @@ int main(int argc, char **argv)
             if (ch == CR) {
               unsigned trig = (cmdcount == UINT_MAX || cmdcount == 0
                                ? 0 : cmdcount - 1);
-              if (cmdbuf[1]) {
+              if (pw.cmdbuf[1]) {
                 unsigned *pnhist = (kbd_state == kbd_colon
                                     ? &ncmdhist : &npathist);
                 unsigned nhist = *pnhist;
                 char ***hist = (kbd_state == kbd_colon ?
                                 &cmdhist : &pathist);
 
-                if (nhist == 0 || strcmp(cmdbuf, (*hist)[0]) != 0) {
+                if (nhist == 0 || strcmp(pw.cmdbuf, (*hist)[0]) != 0) {
                   if ((*hist = realloc(*hist, sizeof **hist * (nhist + 1))) == 0)
                     panic("out of memory");
                   memmove(*hist + 1, *hist, sizeof **hist * nhist);
                   *pnhist = nhist + 1;
-                  (*hist)[0] = dsdup(cmdbuf);
+                  (*hist)[0] = dsdup(pw.cmdbuf);
                 }
               }
 
-              if (kbd_state == kbd_colon && cmdbuf[1]) {
-                execute(cmdbuf, &stat, hist);
-                if (cmdbuf[0] != 0) {
+              if (kbd_state == kbd_colon && pw.cmdbuf[1]) {
+                execute(&pw, pw.cmdbuf);
+                if (pw.cmdbuf[0] != 0) {
                   kbd_state = kbd_result;
                   break;
                 }
               } else if (kbd_state == kbd_trig && (int) trig < maxlines && trig < maxtrig) {
-                char *rx = cmdbuf + 1;
+                char *rx = pw.cmdbuf + 1;
                 int inv = 0;
                 grep *gr = 0;
 
@@ -1293,12 +1298,12 @@ int main(int argc, char **argv)
                 char *pat = dsdup(rx);
 
                 if (*pat && (gr = grnew(dsref(pat), inv, dsdrop), grerr(gr) != 0)) {
-                  grerrstr(gr, cmdbuf, min(columns, (int) sizeof cmdbuf));
+                  grerrstr(gr, pw.cmdbuf, min(pw.columns, (int) sizeof pw.cmdbuf));
                   grfree(gr);
                   kbd_state = kbd_result;
                 } else {
-                  if ((cmdbuf[0] == '/' && (stat & stat_ttmode)) ||
-                      (cmdbuf[0] == '?' && (stat & stat_htmode)))
+                  if ((pw.cmdbuf[0] == '/' && (pw.stat & stat_ttmode)) ||
+                      (pw.cmdbuf[0] == '?' && (pw.stat & stat_htmode)))
                   {
                     for (int i = 0; i < maxtrig; i++) {
                       grfree(triglist[i]);
@@ -1313,10 +1318,10 @@ int main(int argc, char **argv)
               }
 
               if (kbd_state == kbd_trig) {
-                stat &= ~(stat_htmode | stat_ttmode);
+                pw.stat &= ~(stat_htmode | stat_ttmode);
                 for (int i = 0; i < maxtrig; i++) {
                   if (triglist[i]) {
-                    stat |= (cmdbuf[0] == '/' ? stat_htmode : stat_ttmode);
+                    pw.stat |= (pw.cmdbuf[0] == '/' ? stat_htmode : stat_ttmode);
                     break;
                   }
                 }
@@ -1324,32 +1329,32 @@ int main(int argc, char **argv)
             }
 
             kbd_state = kbd_cmd;
-            curcmd = 0;
+            pw.curcmd = 0;
             cmdcount = UINT_MAX;
             break;
           case BS: case DEL:
             {
-              size_t len = strlen(cmdbuf);
+              size_t len = strlen(pw.cmdbuf);
               if (len == 1) {
                 kbd_state = kbd_cmd;
-                curcmd = 0;
+                pw.curcmd = 0;
                 // cmdcount deliberately not reset to UNIT_MAX
               } else {
-                cmdbuf[--len] = 0;
+                pw.cmdbuf[--len] = 0;
               }
             }
             break;
           case ctrl('u'):
-            cmdbuf[1] = 0;
+            pw.cmdbuf[1] = 0;
             break;
           case ctrl('w'):
             {
-              size_t len = strlen(cmdbuf);
-              while (len > 1 && isspace((unsigned char) cmdbuf[len - 1]))
+              size_t len = strlen(pw.cmdbuf);
+              while (len > 1 && isspace((unsigned char) pw.cmdbuf[len - 1]))
                 len--;
-              while (len > 1 && !isspace((unsigned char) cmdbuf[len - 1]))
+              while (len > 1 && !isspace((unsigned char) pw.cmdbuf[len - 1]))
                 len--;
-              cmdbuf[len] = 0;
+              pw.cmdbuf[len] = 0;
             }
             break;
           case ctrl('p'):
@@ -1360,29 +1365,29 @@ int main(int argc, char **argv)
 
               if (ch == ctrl('p')) {
                 if (histpos == 0) {
-                  dsdrop(savedcmd);
-                  savedcmd = dsdup(cmdbuf);
+                  dsdrop(pw.savedcmd);
+                  pw.savedcmd = dsdup(pw.cmdbuf);
                 } else {
                   dsdrop((*hist)[histpos-1]);
-                  (*hist)[histpos-1] = dsdup(cmdbuf);
+                  (*hist)[histpos-1] = dsdup(pw.cmdbuf);
                 }
                 if (histpos < nhist) {
                   char *cmd = (*hist)[histpos++];
-                  strcpy(cmdbuf, cmd);
+                  strcpy(pw.cmdbuf, cmd);
                 }
               } else {
                 if (histpos >= 1) {
                   dsdrop((*hist)[histpos-1]);
-                  (*hist)[histpos-1] = dsdup(cmdbuf);
+                  (*hist)[histpos-1] = dsdup(pw.cmdbuf);
                 }
                 if (histpos > 1) {
                   char *cmd = (*hist)[--histpos - 1];
-                  strcpy(cmdbuf, cmd);
+                  strcpy(pw.cmdbuf, cmd);
                 } else if (histpos == 1) {
                   --histpos;
-                  strcpy(cmdbuf, savedcmd);
-                  dsdrop(savedcmd);
-                  savedcmd = 0;
+                  strcpy(pw.cmdbuf, pw.savedcmd);
+                  dsdrop(pw.savedcmd);
+                  pw.savedcmd = 0;
                 }
               }
             }
@@ -1390,10 +1395,10 @@ int main(int argc, char **argv)
           default:
             if (isprint(ch))
             {
-              size_t len = strlen(cmdbuf);
-              if (len < sizeof cmdbuf - 1 && (int) len < columns - 1) {
-                cmdbuf[len++] = ch;
-                cmdbuf[len] = 0;
+              size_t len = strlen(pw.cmdbuf);
+              if (len < sizeof pw.cmdbuf - 1 && (int) len < pw.columns - 1) {
+                pw.cmdbuf[len++] = ch;
+                pw.cmdbuf[len] = 0;
               }
             }
             break;
@@ -1403,12 +1408,12 @@ int main(int argc, char **argv)
           break;
         }
 
-        if ((stat & (stat_dirty | stat_force))) {
-          stat = redraw(circbuf, nlines, hpos, hist, columns, stat, curcmd);
+        if ((pw.stat & (stat_dirty | stat_force))) {
+          redraw(&pw);
         } else switch (kbd_state) {
         case kbd_colon: case kbd_trig: case kbd_result: case kbd_cmd:
-          clrline(stat);
-          drawstatus(hist, columns, stat, curcmd);
+          clrline(pw.stat);
+          drawstatus(&pw);
         }
       } else {
         work = workbout += workbout / 4;
@@ -1416,8 +1421,8 @@ int main(int argc, char **argv)
     }
   }
 
-  if ((stat & stat_bkgnd) == 0) {
-    clrline(stat);
+  if ((pw.stat & stat_bkgnd) == 0) {
+    clrline(pw.stat);
     ttyset(ttyfd, &tty_saved);
   }