add gitignore, clang-format, build script; merge src's patch for spaces in filenames

.clang-format

@@ -0,0 +1,23 @@
+TabWidth: 2
+IndentWidth: 2
+ContinuationIndentWidth: 2
+UseTab: Never
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+PenaltyReturnTypeOnItsOwnLine: 255
+IndentCaseLabels: true
+SpaceBeforeParens: ControlStatements
+AlignAfterOpenBracket: AlwaysBreak
+BinPackArguments: false
+BinPackArguments: false
+PointerAlignment: Left
+BreakBeforeBraces: Attach
+SortIncludes: false
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AlignEscapedNewlines: Left
+

.gitignore

@@ -1,2 +1,3 @@
 **/*.o
 **/o.*
+acme

addr.c

@@ -12,39 +12,27 @@
 #include "dat.h"
 #include "fns.h"
 
-enum
+enum { None = 0, Fore = '+', Back = '-' };
-{
-	None = 0,
-	Fore = '+',
-	Back = '-'
-};
 
-enum
+enum { Char, Line };
-{
-	Char,
-	Line
-};
 
-int
+int isaddrc(int r) {
-isaddrc(int r)
+  if (r && utfrune("0123456789+-/$.#,;?", r) != nil)
-{
-	if(r && utfrune("0123456789+-/$.#,;?", r)!=nil)
     return TRUE;
   return FALSE;
 }
 
 /*
- * quite hard: could be almost anything but white space, but we are a little conservative,
+ * quite hard: could be almost anything but white space, but we are a little
- * aiming for regular expressions of alphanumerics and no white space
+ * conservative, aiming for regular expressions of alphanumerics and no white
+ * space
  */
-int
+int isregexc(int r) {
-isregexc(int r)
+  if (r == 0)
-{
-	if(r == 0)
     return FALSE;
-	if(isalnum(r))
+  if (isalnum(r))
     return TRUE;
-	if(utfrune("^+-.*?#,;[]()$", r)!=nil)
+  if (utfrune("^+-.*?#,;[]()$", r) != nil)
     return TRUE;
   return FALSE;
 }
@@ -54,130 +42,125 @@ isregexc(int r)
 // and then nr chars, being careful not to walk past
 // the end of the current line.
 // It returns the final position.
-long
+long nlcounttopos(Text* t, long q0, long nl, long nr) {
-nlcounttopos(Text *t, long q0, long nl, long nr)
+  while (nl > 0 && q0 < t->file->b.nc) {
-{
+    if (textreadc(t, q0++) == '\n')
-	while(nl > 0 && q0 < t->file->b.nc) {
-		if(textreadc(t, q0++) == '\n')
       nl--;
   }
-	if(nl > 0)
+  if (nl > 0)
     return q0;
-	while(nr > 0 && q0 < t->file->b.nc && textreadc(t, q0) != '\n') {
+  while (nr > 0 && q0 < t->file->b.nc && textreadc(t, q0) != '\n') {
     q0++;
     nr--;
   }
   return q0;
 }
 
-Range
+Range number(
-number(uint showerr, Text *t, Range r, int line, int dir, int size, int *evalp)
+  uint showerr, Text* t, Range r, int line, int dir, int size, int* evalp) {
-{
   uint q0, q1;
 
-	if(size == Char){
+  if (size == Char) {
-		if(dir == Fore)
+    if (dir == Fore)
-			line = r.q1+line;
+      line = r.q1 + line;
-		else if(dir == Back){
+    else if (dir == Back) {
-			if(r.q0==0 && line>0)
+      if (r.q0 == 0 && line > 0)
         r.q0 = t->file->b.nc;
       line = r.q0 - line;
     }
-		if(line<0 || line>t->file->b.nc)
+    if (line < 0 || line > t->file->b.nc)
       goto Rescue;
     *evalp = TRUE;
     return range(line, line);
   }
   q0 = r.q0;
   q1 = r.q1;
-	switch(dir){
+  switch (dir) {
     case None:
       q0 = 0;
       q1 = 0;
     Forward:
-		while(line>0 && q1<t->file->b.nc)
+      while (line > 0 && q1 < t->file->b.nc)
-			if(textreadc(t, q1++) == '\n' || q1==t->file->b.nc)
+        if (textreadc(t, q1++) == '\n' || q1 == t->file->b.nc)
-				if(--line > 0)
+          if (--line > 0)
             q0 = q1;
-		if(line==1 && q1==t->file->b.nc) // 6 goes to end of 5-line file
+      if (line == 1 && q1 == t->file->b.nc) // 6 goes to end of 5-line file
         break;
-		if(line > 0)
+      if (line > 0)
         goto Rescue;
       break;
     case Fore:
-		if(q1 > 0)
+      if (q1 > 0)
-			while(q1<t->file->b.nc && textreadc(t, q1-1) != '\n')
+        while (q1 < t->file->b.nc && textreadc(t, q1 - 1) != '\n')
           q1++;
       q0 = q1;
       goto Forward;
     case Back:
-		if(q0 < t->file->b.nc)
+      if (q0 < t->file->b.nc)
-			while(q0>0 && textreadc(t, q0-1)!='\n')
+        while (q0 > 0 && textreadc(t, q0 - 1) != '\n')
           q0--;
       q1 = q0;
-		while(line>0 && q0>0){
+      while (line > 0 && q0 > 0) {
-			if(textreadc(t, q0-1) == '\n'){
+        if (textreadc(t, q0 - 1) == '\n') {
-				if(--line >= 0)
+          if (--line >= 0)
             q1 = q0;
         }
         --q0;
       }
       /* :1-1 is :0 = #0, but :1-2 is an error */
-		if(line > 1)
+      if (line > 1)
         goto Rescue;
-		while(q0>0 && textreadc(t, q0-1)!='\n')
+      while (q0 > 0 && textreadc(t, q0 - 1) != '\n')
         --q0;
   }
   *evalp = TRUE;
   return range(q0, q1);
 
-    Rescue:
+Rescue:
-	if(showerr)
+  if (showerr)
     warning(nil, "address out of range\n");
   *evalp = FALSE;
   return r;
 }
 
-
+Range regexp(
-Range
+  uint showerr, Text* t, Range lim, Range r, Rune* pat, int dir, int* foundp) {
-regexp(uint showerr, Text *t, Range lim, Range r, Rune *pat, int dir, int *foundp)
-{
   int found;
   Rangeset sel;
   int q;
 
-	if(pat[0] == '\0' && rxnull()){
+  if (pat[0] == '\0' && rxnull()) {
-		if(showerr)
+    if (showerr)
       warning(nil, "no previous regular expression\n");
     *foundp = FALSE;
     return r;
   }
-	if(pat[0] && rxcompile(pat) == FALSE){
+  if (pat[0] && rxcompile(pat) == FALSE) {
     *foundp = FALSE;
     return r;
   }
-	if(dir == Back)
+  if (dir == Back)
     found = rxbexecute(t, r.q0, &sel);
-	else{
+  else {
-		if(lim.q0 < 0)
+    if (lim.q0 < 0)
       q = Infinity;
     else
       q = lim.q1;
     found = rxexecute(t, nil, r.q1, q, &sel);
   }
-	if(!found && showerr)
+  if (!found && showerr)
     warning(nil, "no match for regexp\n");
   *foundp = found;
   return sel.r[0];
 }
 
-Range
+Range address(
-address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, int (*getc)(void*, uint),  int *evalp, uint *qp)
+  uint showerr, Text* t, Range lim, Range ar, void* a, uint q0, uint q1,
-{
+  int (*getc)(void*, uint), int* evalp, uint* qp) {
   int dir, size, npat;
   int prevc, c, nc, n;
   uint q;
-	Rune *pat;
+  Rune* pat;
   Range r, nr;
 
   r = ar;
@@ -185,22 +168,22 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
   dir = None;
   size = Line;
   c = 0;
-	while(q < q1){
+  while (q < q1) {
     prevc = c;
     c = (*getc)(a, q++);
-		switch(c){
+    switch (c) {
       default:
-			*qp = q-1;
+        *qp = q - 1;
         return r;
       case ';':
         ar = r;
         /* fall through */
       case ',':
-			if(prevc == 0)	/* lhs defaults to 0 */
+        if (prevc == 0) /* lhs defaults to 0 */
           r.q0 = 0;
-			if(q>=q1 && t!=nil && t->file!=nil)	/* rhs defaults to $ */
+        if (q >= q1 && t != nil && t->file != nil) /* rhs defaults to $ */
           r.q1 = t->file->b.nc;
-			else{
+        else {
           nr = address(showerr, t, lim, ar, a, q, q1, getc, evalp, &q);
           r.q1 = nr.q1;
         }
@@ -208,46 +191,55 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
         return r;
       case '+':
       case '-':
-			if(*evalp && (prevc=='+' || prevc=='-'))
+        if (*evalp && (prevc == '+' || prevc == '-'))
-				if((nc=(*getc)(a, q))!='#' && nc!='/' && nc!='?')
+          if ((nc = (*getc)(a, q)) != '#' && nc != '/' && nc != '?')
-					r = number(showerr, t, r, 1, prevc, Line, evalp);	/* do previous one */
+            r = number(showerr, t, r, 1, prevc, Line, evalp); /* do previous one
+                                                               */
         dir = c;
         break;
       case '.':
       case '$':
-			if(q != q0+1){
+        if (q != q0 + 1) {
-				*qp = q-1;
+          *qp = q - 1;
           return r;
         }
-			if(*evalp)
+        if (*evalp)
-				if(c == '.')
+          if (c == '.')
             r = ar;
           else
             r = range(t->file->b.nc, t->file->b.nc);
-			if(q < q1)
+        if (q < q1)
           dir = Fore;
         else
           dir = None;
         break;
       case '#':
-			if(q==q1 || (c=(*getc)(a, q++))<'0' || '9'<c){
+        if (q == q1 || (c = (*getc)(a, q++)) < '0' || '9' < c) {
-				*qp = q-1;
+          *qp = q - 1;
           return r;
         }
         size = Char;
         /* fall through */
-		case '0': case '1': case '2': case '3': case '4':
+      case '0':
-		case '5': case '6': case '7': case '8': case '9':
+      case '1':
-			n = c -'0';
+      case '2':
-			while(q<q1){
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+        n = c - '0';
+        while (q < q1) {
           nc = (*getc)(a, q++);
-				if(nc<'0' || '9'<nc){
+          if (nc < '0' || '9' < nc) {
             q--;
             break;
           }
-				n = n*10+(nc-'0');
+          n = n * 10 + (nc - '0');
         }
-			if(*evalp)
+        if (*evalp)
           r = number(showerr, t, r, n, dir, size, evalp);
         dir = None;
         size = Line;
@@ -258,29 +250,29 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
       case '/':
         npat = 0;
         pat = nil;
-			while(q<q1){
+        while (q < q1) {
           c = (*getc)(a, q++);
-				switch(c){
+          switch (c) {
             case '\n':
               --q;
               goto out;
             case '\\':
-					pat = runerealloc(pat, npat+1);
+              pat = runerealloc(pat, npat + 1);
               pat[npat++] = c;
-					if(q == q1)
+              if (q == q1)
                 goto out;
               c = (*getc)(a, q++);
               break;
             case '/':
               goto out;
           }
-				pat = runerealloc(pat, npat+1);
+          pat = runerealloc(pat, npat + 1);
           pat[npat++] = c;
         }
       out:
-			pat = runerealloc(pat, npat+1);
+        pat = runerealloc(pat, npat + 1);
         pat[npat] = 0;
-			if(*evalp)
+        if (*evalp)
           r = regexp(showerr, t, lim, r, pat, dir, evalp);
         free(pat);
         dir = None;
@@ -288,7 +280,7 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
         break;
     }
   }
-	if(*evalp && dir != None)
+  if (*evalp && dir != None)
     r = number(showerr, t, r, 1, dir, Line, evalp); /* do previous one */
   *qp = q;
   return r;

buff.c

@@ -12,47 +12,37 @@
 #include "dat.h"
 #include "fns.h"
 
-enum
+enum {
-{
   Slop = 100 /* room to grow with reallocation */
 };
 
-static
+static void sizecache(Buffer* b, uint n) {
-void
+  if (n <= b->cmax)
-sizecache(Buffer *b, uint n)
-{
-	if(n <= b->cmax)
     return;
-	b->cmax = n+Slop;
+  b->cmax = n + Slop;
   b->c = runerealloc(b->c, b->cmax);
 }
 
-static
+static void addblock(Buffer* b, uint i, uint n) {
-void
+  if (i > b->nbl)
-addblock(Buffer *b, uint i, uint n)
-{
-	if(i > b->nbl)
     error("internal error: addblock");
 
-	b->bl = realloc(b->bl, (b->nbl+1)*sizeof b->bl[0]);
+  b->bl = realloc(b->bl, (b->nbl + 1) * sizeof b->bl[0]);
-	if(i < b->nbl)
+  if (i < b->nbl)
-		memmove(b->bl+i+1, b->bl+i, (b->nbl-i)*sizeof(Block*));
+    memmove(b->bl + i + 1, b->bl + i, (b->nbl - i) * sizeof(Block*));
   b->bl[i] = disknewblock(disk, n);
   b->nbl++;
 }
 
-static
+static void delblock(Buffer* b, uint i) {
-void
+  if (i >= b->nbl)
-delblock(Buffer *b, uint i)
-{
-	if(i >= b->nbl)
     error("internal error: delblock");
 
   diskrelease(disk, b->bl[i]);
   b->nbl--;
-	if(i < b->nbl)
+  if (i < b->nbl)
-		memmove(b->bl+i, b->bl+i+1, (b->nbl-i)*sizeof(Block*));
+    memmove(b->bl + i, b->bl + i + 1, (b->nbl - i) * sizeof(Block*));
-	b->bl = realloc(b->bl, b->nbl*sizeof b->bl[0]);
+  b->bl = realloc(b->bl, b->nbl * sizeof b->bl[0]);
 }
 
 /*
@@ -60,12 +50,9 @@ delblock(Buffer *b, uint i)
  * If at very end, q0 will fall on end of cache block.
  */
 
-static
+static void flush(Buffer* b) {
-void
+  if (b->cdirty || b->cnc == 0) {
-flush(Buffer *b)
+    if (b->cnc == 0)
-{
-	if(b->cdirty || b->cnc==0){
-		if(b->cnc == 0)
       delblock(b, b->cbi);
     else
       diskwrite(disk, &b->bl[b->cbi], b->c, b->cnc);
@@ -73,40 +60,37 @@ flush(Buffer *b)
   }
 }
 
-static
+static void setcache(Buffer* b, uint q0) {
-void
-setcache(Buffer *b, uint q0)
-{
   Block **blp, *bl;
   uint i, q;
 
-	if(q0 > b->nc)
+  if (q0 > b->nc)
     error("internal error: setcache");
   /*
    * flush and reload if q0 is not in cache.
    */
-	if(b->nc == 0 || (b->cq<=q0 && q0<b->cq+b->cnc))
+  if (b->nc == 0 || (b->cq <= q0 && q0 < b->cq + b->cnc))
     return;
   /*
    * if q0 is at end of file and end of cache, continue to grow this block
    */
-	if(q0==b->nc && q0==b->cq+b->cnc && b->cnc<Maxblock)
+  if (q0 == b->nc && q0 == b->cq + b->cnc && b->cnc < Maxblock)
     return;
   flush(b);
   /* find block */
-	if(q0 < b->cq){
+  if (q0 < b->cq) {
     q = 0;
     i = 0;
-	}else{
+  } else {
     q = b->cq;
     i = b->cbi;
   }
   blp = &b->bl[i];
-	while(q+(*blp)->u.n <= q0 && q+(*blp)->u.n < b->nc){
+  while (q + (*blp)->u.n <= q0 && q + (*blp)->u.n < b->nc) {
     q += (*blp)->u.n;
     i++;
     blp++;
-		if(i >= b->nbl)
+    if (i >= b->nbl)
       error("block not found");
   }
   bl = *blp;
@@ -119,30 +103,28 @@ setcache(Buffer *b, uint q0)
   diskread(disk, bl, b->c, b->cnc);
 }
 
-void
+void bufinsert(Buffer* b, uint q0, Rune* s, uint n) {
-bufinsert(Buffer *b, uint q0, Rune *s, uint n)
-{
   uint i, m, t, off;
 
-	if(q0 > b->nc)
+  if (q0 > b->nc)
     error("internal error: bufinsert");
 
-	while(n > 0){
+  while (n > 0) {
     setcache(b, q0);
-		off = q0-b->cq;
+    off = q0 - b->cq;
-		if(b->cnc+n <= Maxblock){
+    if (b->cnc + n <= Maxblock) {
       /* Everything fits in one block. */
-			t = b->cnc+n;
+      t = b->cnc + n;
       m = n;
-			if(b->bl == nil){	/* allocate */
+      if (b->bl == nil) { /* allocate */
-				if(b->cnc != 0)
+        if (b->cnc != 0)
           error("internal error: bufinsert1 cnc!=0");
         addblock(b, 0, t);
         b->cbi = 0;
       }
       sizecache(b, t);
-			runemove(b->c+off+m, b->c+off, b->cnc-off);
+      runemove(b->c + off + m, b->c + off, b->cnc - off);
-			runemove(b->c+off, s, m);
+      runemove(b->c + off, s, m);
       b->cnc = t;
       goto Tail;
     }
@@ -151,17 +133,17 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
      * the very beginning or end of this block,
      * just make a new block and fill it.
      */
-		if(q0==b->cq || q0==b->cq+b->cnc){
+    if (q0 == b->cq || q0 == b->cq + b->cnc) {
-			if(b->cdirty)
+      if (b->cdirty)
         flush(b);
       m = min(n, Maxblock);
-			if(b->bl == nil){	/* allocate */
+      if (b->bl == nil) { /* allocate */
-				if(b->cnc != 0)
+        if (b->cnc != 0)
           error("internal error: bufinsert2 cnc!=0");
         i = 0;
-			}else{
+      } else {
         i = b->cbi;
-				if(q0 > b->cq)
+        if (q0 > b->cq)
           i++;
       }
       addblock(b, i, m);
@@ -176,20 +158,20 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
      * Split the block; cut off the right side and
      * let go of it.
      */
-		m = b->cnc-off;
+    m = b->cnc - off;
-		if(m > 0){
+    if (m > 0) {
-			i = b->cbi+1;
+      i = b->cbi + 1;
       addblock(b, i, m);
-			diskwrite(disk, &b->bl[i], b->c+off, m);
+      diskwrite(disk, &b->bl[i], b->c + off, m);
       b->cnc -= m;
     }
     /*
      * Now at end of block.  Take as much input
      * as possible and tack it on end of block.
      */
-		m = min(n, Maxblock-b->cnc);
+    m = min(n, Maxblock - b->cnc);
-		sizecache(b, b->cnc+m);
+    sizecache(b, b->cnc + m);
-		runemove(b->c+b->cnc, s, m);
+    runemove(b->c + b->cnc, s, m);
     b->cnc += m;
   Tail:
     b->nc += m;
@@ -200,23 +182,21 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
   }
 }
 
-void
+void bufdelete(Buffer* b, uint q0, uint q1) {
-bufdelete(Buffer *b, uint q0, uint q1)
-{
   uint m, n, off;
 
-	if(!(q0<=q1 && q0<=b->nc && q1<=b->nc))
+  if (!(q0 <= q1 && q0 <= b->nc && q1 <= b->nc))
     error("internal error: bufdelete");
-	while(q1 > q0){
+  while (q1 > q0) {
     setcache(b, q0);
-		off = q0-b->cq;
+    off = q0 - b->cq;
-		if(q1 > b->cq+b->cnc)
+    if (q1 > b->cq + b->cnc)
       n = b->cnc - off;
     else
-			n = q1-q0;
+      n = q1 - q0;
-		m = b->cnc - (off+n);
+    m = b->cnc - (off + n);
-		if(m > 0)
+    if (m > 0)
-			runemove(b->c+off, b->c+off+n, m);
+      runemove(b->c + off, b->c + off + n, m);
     b->cnc -= n;
     b->cdirty = TRUE;
     q1 -= n;
@@ -224,22 +204,20 @@ bufdelete(Buffer *b, uint q0, uint q1)
   }
 }
 
-static int
+static int bufloader(void* v, uint q0, Rune* r, int nr) {
-bufloader(void *v, uint q0, Rune *r, int nr)
-{
   bufinsert(v, q0, r, nr);
   return nr;
 }
 
-uint
+uint loadfile(
-loadfile(int fd, uint q0, int *nulls, int(*f)(void*, uint, Rune*, int), void *arg, DigestState *h)
+  int fd, uint q0, int* nulls, int (*f)(void*, uint, Rune*, int), void* arg,
-{
+  DigestState* h) {
-	char *p;
+  char* p;
-	Rune *r;
+  Rune* r;
   int l, m, n, nb, nr;
   uint q1;
 
-	p = emalloc((Maxblock+UTFmax+1)*sizeof p[0]);
+  p = emalloc((Maxblock + UTFmax + 1) * sizeof p[0]);
   r = runemalloc(Maxblock);
   m = 0;
   n = 1;
@@ -248,58 +226,52 @@ loadfile(int fd, uint q0, int *nulls, int(*f)(void*, uint, Rune*, int), void *ar
    * At top of loop, may have m bytes left over from
    * last pass, possibly representing a partial rune.
    */
-	while(n > 0){
+  while (n > 0) {
-		n = read(fd, p+m, Maxblock);
+    n = read(fd, p + m, Maxblock);
-		if(n < 0){
+    if (n < 0) {
       warning(nil, "read error in Buffer.load");
       break;
     }
-		if(h != nil)
+    if (h != nil)
-			sha1((uchar*)p+m, n, nil, h);
+      sha1((uchar*)p + m, n, nil, h);
     m += n;
     p[m] = 0;
     l = m;
-		if(n > 0)
+    if (n > 0)
       l -= UTFmax;
     cvttorunes(p, l, r, &nb, &nr, nulls);
-		memmove(p, p+nb, m-nb);
+    memmove(p, p + nb, m - nb);
     m -= nb;
     q1 += (*f)(arg, q1, r, nr);
   }
   free(p);
   free(r);
-	return q1-q0;
+  return q1 - q0;
 }
 
-uint
+uint bufload(Buffer* b, uint q0, int fd, int* nulls, DigestState* h) {
-bufload(Buffer *b, uint q0, int fd, int *nulls, DigestState *h)
+  if (q0 > b->nc)
-{
-	if(q0 > b->nc)
     error("internal error: bufload");
   return loadfile(fd, q0, nulls, bufloader, b, h);
 }
 
-void
+void bufread(Buffer* b, uint q0, Rune* s, uint n) {
-bufread(Buffer *b, uint q0, Rune *s, uint n)
-{
   uint m;
 
-	if(!(q0<=b->nc && q0+n<=b->nc))
+  if (!(q0 <= b->nc && q0 + n <= b->nc))
     error("bufread: internal error");
 
-	while(n > 0){
+  while (n > 0) {
     setcache(b, q0);
-		m = min(n, b->cnc-(q0-b->cq));
+    m = min(n, b->cnc - (q0 - b->cq));
-		runemove(s, b->c+(q0-b->cq), m);
+    runemove(s, b->c + (q0 - b->cq), m);
     q0 += m;
     s += m;
     n -= m;
   }
 }
 
-void
+void bufreset(Buffer* b) {
-bufreset(Buffer *b)
-{
   int i;
 
   b->nc = 0;
@@ -308,13 +280,11 @@ bufreset(Buffer *b)
   b->cdirty = 0;
   b->cbi = 0;
   /* delete backwards to avoid n² behavior */
-	for(i=b->nbl-1; --i>=0; )
+  for (i = b->nbl - 1; --i >= 0;)
     delblock(b, i);
 }
 
-void
+void bufclose(Buffer* b) {
-bufclose(Buffer *b)
-{
   bufreset(b);
   free(b->c);
   b->c = nil;

build.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+clang-format -i ./*.c
+clang-format -i ./mail/*.c
+
+mk
+
+mv o.acme acme

cols.c

@@ -12,24 +12,21 @@
 #include "dat.h"
 #include "fns.h"
 
-static Rune Lheader[] = {
+static Rune Lheader[] = {'N', 'e', 'w', ' ', 'C', 'u', 't', ' ', 'P', 'a',
-	'N', 'e', 'w', ' ',
+                         's', 't', 'e', ' ', 'S', 'n', 'a', 'r', 'f', ' ',
-	'C', 'u', 't', ' ',
+                         'S', 'o', 'r', 't', ' ', 'Z', 'e', 'r', 'o', 'x',
-	'P', 'a', 's', 't', 'e', ' ',
+                         ' ', 'D', 'e', 'l', 'c', 'o', 'l', ' ', 0};
-	'S', 'n', 'a', 'r', 'f', ' ',
-	'S', 'o', 'r', 't', ' ',
-	'Z', 'e', 'r', 'o', 'x', ' ',
-	'D', 'e', 'l', 'c', 'o', 'l', ' ',
-	0
-};
 
-void
+void colinit(Column* c, Rectangle r) {
-colinit(Column *c, Rectangle r)
-{
   Rectangle r1;
-	Text *t;
+  Text* t;
 
-	draw(screen, r, allocimage(display,Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+  draw(
+    screen,
+    r,
+    allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+    nil,
+    ZP);
   c->r = r;
   c->w = nil;
   c->nw = 0;
@@ -42,44 +39,47 @@ colinit(Column *c, Rectangle r)
   t->what = Columntag;
   r1.min.y = r1.max.y;
   r1.max.y += Border;
-	draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+  draw(
+    screen,
+    r1,
+    allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+    nil,
+    ZP);
   textinsert(t, 0, Lheader, 38, TRUE);
   textsetselect(t, t->file->b.nc, t->file->b.nc);
   draw(screen, t->scrollr, colbutton, nil, colbutton->r.min);
   c->safe = TRUE;
 }
 
-Window*
+Window* coladd(Column* c, Window* w, Window* clone, int y) {
-coladd(Column *c, Window *w, Window *clone, int y)
-{
   Rectangle r, r1;
-	Window *v;
+  Window* v;
   int i, j, minht, ymax, buggered;
 
   v = nil;
   r = c->r;
-	r.min.y = c->tag.fr.r.max.y+Border;
+  r.min.y = c->tag.fr.r.max.y + Border;
-	if(y<r.min.y && c->nw>0){	/* steal half of last window by default */
+  if (y < r.min.y && c->nw > 0) { /* steal half of last window by default */
-		v = c->w[c->nw-1];
+    v = c->w[c->nw - 1];
-		y = v->body.fr.r.min.y+Dy(v->body.fr.r)/2;
+    y = v->body.fr.r.min.y + Dy(v->body.fr.r) / 2;
   }
   /* look for window we'll land on */
-	for(i=0; i<c->nw; i++){
+  for (i = 0; i < c->nw; i++) {
     v = c->w[i];
-		if(y < v->r.max.y)
+    if (y < v->r.max.y)
       break;
   }
   buggered = 0;
-	if(c->nw > 0){
+  if (c->nw > 0) {
-		if(i < c->nw)
+    if (i < c->nw)
       i++; /* new window will go after v */
     /*
      * if landing window (v) is too small, grow it first.
      */
-		minht = v->tag.fr.font->height+Border+1;
+    minht = v->tag.fr.font->height + Border + 1;
     j = 0;
-		while(!c->safe || v->body.fr.maxlines<=3 || Dy(v->body.all) <= minht){
+    while (!c->safe || v->body.fr.maxlines <= 3 || Dy(v->body.all) <= minht) {
-			if(++j > 10){
+      if (++j > 10) {
         buggered = 1; /* too many windows in column */
         break;
       }
@@ -91,19 +91,19 @@ coladd(Column *c, Window *w, Window *clone, int y)
      */
 
     /* new window stops where next window begins */
-		if(i < c->nw)
+    if (i < c->nw)
-			ymax = c->w[i]->r.min.y-Border;
+      ymax = c->w[i]->r.min.y - Border;
     else
       ymax = c->r.max.y;
 
     /* new window must start after v's tag ends */
-		y = max(y, v->tagtop.max.y+Border);
+    y = max(y, v->tagtop.max.y + Border);
 
     /* new window must start early enough to end before ymax */
     y = min(y, ymax - minht);
 
     /* if y is too small, too many windows in column */
-		if(y < v->tagtop.max.y+Border)
+    if (y < v->tagtop.max.y + Border)
       buggered = 1;
 
     /*
@@ -113,23 +113,32 @@ coladd(Column *c, Window *w, Window *clone, int y)
     r.max.y = ymax;
     draw(screen, r, textcols[BACK], nil, ZP);
     r1 = r;
-		y = min(y, ymax-(v->tag.fr.font->height*v->taglines+v->body.fr.font->height+Border+1));
+    y = min(
-		r1.max.y = min(y, v->body.fr.r.min.y+v->body.fr.nlines*v->body.fr.font->height);
+      y,
+      ymax - (v->tag.fr.font->height * v->taglines + v->body.fr.font->height +
+              Border + 1));
+    r1.max.y =
+      min(y, v->body.fr.r.min.y + v->body.fr.nlines * v->body.fr.font->height);
     r1.min.y = winresize(v, r1, FALSE, FALSE);
-		r1.max.y = r1.min.y+Border;
+    r1.max.y = r1.min.y + Border;
-		draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
+      screen,
+      r1,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
 
     /*
      * leave r with w's coordinates
      */
     r.min.y = r1.max.y;
   }
-	if(w == nil){
+  if (w == nil) {
     w = emalloc(sizeof(Window));
     w->col = c;
     draw(screen, r, textcols[BACK], nil, ZP);
     wininit(w, clone, r);
-	}else{
+  } else {
     w->col = c;
     winresize(w, r, FALSE, TRUE);
   }
@@ -137,14 +146,14 @@ coladd(Column *c, Window *w, Window *clone, int y)
   w->tag.row = c->row;
   w->body.col = c;
   w->body.row = c->row;
-	c->w = realloc(c->w, (c->nw+1)*sizeof(Window*));
+  c->w = realloc(c->w, (c->nw + 1) * sizeof(Window*));
-	memmove(c->w+i+1, c->w+i, (c->nw-i)*sizeof(Window*));
+  memmove(c->w + i + 1, c->w + i, (c->nw - i) * sizeof(Window*));
   c->nw++;
   c->w[i] = w;
   c->safe = TRUE;
 
   /* if there were too many windows, redraw the whole column */
-	if(buggered)
+  if (buggered)
     colresize(c, c->r);
 
   savemouse(w);
@@ -154,66 +163,67 @@ coladd(Column *c, Window *w, Window *clone, int y)
   return w;
 }
 
-void
+void colclose(Column* c, Window* w, int dofree) {
-colclose(Column *c, Window *w, int dofree)
-{
   Rectangle r;
   int i, didmouse, up;
 
   /* w is locked */
-	if(!c->safe)
+  if (!c->safe)
     colgrow(c, w, 1);
-	for(i=0; i<c->nw; i++)
+  for (i = 0; i < c->nw; i++)
-		if(c->w[i] == w)
+    if (c->w[i] == w)
       goto Found;
   error("can't find window");
-  Found:
+Found:
   r = w->r;
   w->tag.col = nil;
   w->body.col = nil;
   w->col = nil;
   didmouse = restoremouse(w);
-	if(dofree){
+  if (dofree) {
     windelete(w);
     winclose(w);
   }
   c->nw--;
-	memmove(c->w+i, c->w+i+1, (c->nw-i)*sizeof(Window*));
+  memmove(c->w + i, c->w + i + 1, (c->nw - i) * sizeof(Window*));
-	c->w = realloc(c->w, c->nw*sizeof(Window*));
+  c->w = realloc(c->w, c->nw * sizeof(Window*));
-	if(c->nw == 0){
+  if (c->nw == 0) {
-		draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
+      screen,
+      r,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
     return;
   }
   up = 0;
-	if(i == c->nw){		/* extend last window down */
+  if (i == c->nw) { /* extend last window down */
-		w = c->w[i-1];
+    w = c->w[i - 1];
     r.min.y = w->r.min.y;
     r.max.y = c->r.max.y;
-	}else{			/* extend next window up */
+  } else { /* extend next window up */
     up = 1;
     w = c->w[i];
     r.max.y = w->r.max.y;
   }
   draw(screen, r, textcols[BACK], nil, ZP);
-	if(c->safe) {
+  if (c->safe) {
-		if(!didmouse && up)
+    if (!didmouse && up)
       w->showdel = TRUE;
     winresize(w, r, FALSE, TRUE);
-		if(!didmouse && up)
+    if (!didmouse && up)
       movetodel(w);
   }
 }
 
-void
+void colcloseall(Column* c) {
-colcloseall(Column *c)
-{
   int i;
-	Window *w;
+  Window* w;
 
-	if(c == activecol)
+  if (c == activecol)
     activecol = nil;
   textclose(&c->tag);
-	for(i=0; i<c->nw; i++){
+  for (i = 0; i < c->nw; i++) {
     w = c->w[i];
     winclose(w);
   }
@@ -223,18 +233,14 @@ colcloseall(Column *c)
   clearmouse();
 }
 
-void
+void colmousebut(Column* c) {
-colmousebut(Column *c)
-{
   moveto(mousectl, divpt(addpt(c->tag.scrollr.min, c->tag.scrollr.max), 2));
 }
 
-void
+void colresize(Column* c, Rectangle r) {
-colresize(Column *c, Rectangle r)
-{
   int i;
   Rectangle r1, r2;
-	Window *w;
+  Window* w;
 
   clearmouse();
   r1 = r;
@@ -243,33 +249,40 @@ colresize(Column *c, Rectangle r)
   draw(screen, c->tag.scrollr, colbutton, nil, colbutton->r.min);
   r1.min.y = r1.max.y;
   r1.max.y += Border;
-	draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+  draw(
+    screen,
+    r1,
+    allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+    nil,
+    ZP);
   r1.max.y = r.max.y;
-	for(i=0; i<c->nw; i++){
+  for (i = 0; i < c->nw; i++) {
     w = c->w[i];
     w->maxlines = 0;
-		if(i == c->nw-1)
+    if (i == c->nw - 1)
       r1.max.y = r.max.y;
-		else{
+    else {
       r1.max.y = r1.min.y;
-			if(Dy(c->r) != 0){
+      if (Dy(c->r) != 0) {
-				r1.max.y += (Dy(w->r)+Border)*Dy(r)/Dy(c->r);
+        r1.max.y += (Dy(w->r) + Border) * Dy(r) / Dy(c->r);
       }
     }
-		r1.max.y = max(r1.max.y, r1.min.y + Border+font->height);
+    r1.max.y = max(r1.max.y, r1.min.y + Border + font->height);
     r2 = r1;
-		r2.max.y = r2.min.y+Border;
+    r2.max.y = r2.min.y + Border;
-		draw(screen, r2, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
+      screen,
+      r2,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
     r1.min.y = r2.max.y;
-		r1.min.y = winresize(w, r1, FALSE, i==c->nw-1);
+    r1.min.y = winresize(w, r1, FALSE, i == c->nw - 1);
   }
   c->r = r;
 }
 
-static
+static int colcmp(const void* a, const void* b) {
-int
-colcmp(const void *a, const void *b)
-{
   Rune *r1, *r2;
   int i, nr1, nr2;
 
@@ -277,86 +290,87 @@ colcmp(const void *a, const void *b)
   nr1 = (*(Window**)a)->body.file->nname;
   r2 = (*(Window**)b)->body.file->name;
   nr2 = (*(Window**)b)->body.file->nname;
-	for(i=0; i<nr1 && i<nr2; i++){
+  for (i = 0; i < nr1 && i < nr2; i++) {
-		if(*r1 != *r2)
+    if (*r1 != *r2)
-			return *r1-*r2;
+      return *r1 - *r2;
     r1++;
     r2++;
   }
-	return nr1-nr2;
+  return nr1 - nr2;
 }
 
-void
+void colsort(Column* c) {
-colsort(Column *c)
-{
   int i, y;
   Rectangle r, r1, *rp;
   Window **wp, *w;
 
-	if(c->nw == 0)
+  if (c->nw == 0)
     return;
   clearmouse();
-	rp = emalloc(c->nw*sizeof(Rectangle));
+  rp = emalloc(c->nw * sizeof(Rectangle));
-	wp = emalloc(c->nw*sizeof(Window*));
+  wp = emalloc(c->nw * sizeof(Window*));
-	memmove(wp, c->w, c->nw*sizeof(Window*));
+  memmove(wp, c->w, c->nw * sizeof(Window*));
   qsort(wp, c->nw, sizeof(Window*), colcmp);
-	for(i=0; i<c->nw; i++)
+  for (i = 0; i < c->nw; i++)
     rp[i] = wp[i]->r;
   r = c->r;
   r.min.y = c->tag.fr.r.max.y;
   draw(screen, r, textcols[BACK], nil, ZP);
   y = r.min.y;
-	for(i=0; i<c->nw; i++){
+  for (i = 0; i < c->nw; i++) {
     w = wp[i];
     r.min.y = y;
-		if(i == c->nw-1)
+    if (i == c->nw - 1)
       r.max.y = c->r.max.y;
     else
-			r.max.y = r.min.y+Dy(w->r)+Border;
+      r.max.y = r.min.y + Dy(w->r) + Border;
     r1 = r;
-		r1.max.y = r1.min.y+Border;
+    r1.max.y = r1.min.y + Border;
-		draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
+      screen,
+      r1,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
     r.min.y = r1.max.y;
-		y = winresize(w, r, FALSE, i==c->nw-1);
+    y = winresize(w, r, FALSE, i == c->nw - 1);
   }
   free(rp);
   free(c->w);
   c->w = wp;
 }
 
-void
+void colgrow(Column* c, Window* w, int but) {
-colgrow(Column *c, Window *w, int but)
-{
   Rectangle r, cr;
   int i, j, k, l, y1, y2, *nl, *ny, tot, nnl, onl, dnl, h;
-	Window *v;
+  Window* v;
 
-	for(i=0; i<c->nw; i++)
+  for (i = 0; i < c->nw; i++)
-		if(c->w[i] == w)
+    if (c->w[i] == w)
       goto Found;
   error("can't find window");
 
-  Found:
+Found:
   cr = c->r;
-	if(but < 0){	/* make sure window fills its own space properly */
+  if (but < 0) { /* make sure window fills its own space properly */
     r = w->r;
-		if(i==c->nw-1 || c->safe==FALSE)
+    if (i == c->nw - 1 || c->safe == FALSE)
       r.max.y = cr.max.y;
     else
-			r.max.y = c->w[i+1]->r.min.y - Border;
+      r.max.y = c->w[i + 1]->r.min.y - Border;
     winresize(w, r, FALSE, TRUE);
     return;
   }
   cr.min.y = c->w[0]->r.min.y;
-	if(but == 3){	/* full size */
+  if (but == 3) { /* full size */
-		if(i != 0){
+    if (i != 0) {
       v = c->w[0];
       c->w[0] = w;
       c->w[i] = v;
     }
     draw(screen, cr, textcols[BACK], nil, ZP);
     winresize(w, cr, FALSE, TRUE);
-		for(i=1; i<c->nw; i++)
+    for (i = 1; i < c->nw; i++)
       c->w[i]->body.fr.maxlines = 0;
     c->safe = FALSE;
     return;
@@ -366,64 +380,69 @@ colgrow(Column *c, Window *w, int but)
   nl = emalloc(c->nw * sizeof(int));
   ny = emalloc(c->nw * sizeof(int));
   tot = 0;
-	for(j=0; j<c->nw; j++){
+  for (j = 0; j < c->nw; j++) {
-		l = c->w[j]->taglines-1 + c->w[j]->body.fr.maxlines;
+    l = c->w[j]->taglines - 1 + c->w[j]->body.fr.maxlines;
     nl[j] = l;
     tot += l;
   }
   /* approximate new #lines for this window */
-	if(but == 2){	/* as big as can be */
+  if (but == 2) { /* as big as can be */
     memset(nl, 0, c->nw * sizeof(int));
     goto Pack;
   }
-	nnl = min(onl + max(min(5, w->taglines-1+w->maxlines), onl/2), tot);
+  nnl = min(onl + max(min(5, w->taglines - 1 + w->maxlines), onl / 2), tot);
-	if(nnl < w->taglines-1+w->maxlines)
+  if (nnl < w->taglines - 1 + w->maxlines)
-		nnl = (w->taglines-1+w->maxlines + nnl)/2;
+    nnl = (w->taglines - 1 + w->maxlines + nnl) / 2;
-	if(nnl == 0)
+  if (nnl == 0)
     nnl = 2;
   dnl = nnl - onl;
   /* compute new #lines for each window */
-	for(k=1; k<c->nw; k++){
+  for (k = 1; k < c->nw; k++) {
     /* prune from later window */
-		j = i+k;
+    j = i + k;
-		if(j<c->nw && nl[j]){
+    if (j < c->nw && nl[j]) {
-			l = min(dnl, max(1, nl[j]/2));
+      l = min(dnl, max(1, nl[j] / 2));
       nl[j] -= l;
       nl[i] += l;
       dnl -= l;
     }
     /* prune from earlier window */
-		j = i-k;
+    j = i - k;
-		if(j>=0 && nl[j]){
+    if (j >= 0 && nl[j]) {
-			l = min(dnl, max(1, nl[j]/2));
+      l = min(dnl, max(1, nl[j] / 2));
       nl[j] -= l;
       nl[i] += l;
       dnl -= l;
     }
   }
-    Pack:
+Pack:
   /* pack everyone above */
   y1 = cr.min.y;
-	for(j=0; j<i; j++){
+  for (j = 0; j < i; j++) {
     v = c->w[j];
     r = v->r;
     r.min.y = y1;
-		r.max.y = y1+Dy(v->tagtop);
+    r.max.y = y1 + Dy(v->tagtop);
-		if(nl[j])
+    if (nl[j])
-			r.max.y += 1 + nl[j]*v->body.fr.font->height;
+      r.max.y += 1 + nl[j] * v->body.fr.font->height;
     r.min.y = winresize(v, r, c->safe, FALSE);
     r.max.y += Border;
-		draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
+      screen,
+      r,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
     y1 = r.max.y;
   }
   /* scan to see new size of everyone below */
   y2 = c->r.max.y;
-	for(j=c->nw-1; j>i; j--){
+  for (j = c->nw - 1; j > i; j--) {
     v = c->w[j];
     r = v->r;
-		r.min.y = y2-Dy(v->tagtop);
+    r.min.y = y2 - Dy(v->tagtop);
-		if(nl[j])
+    if (nl[j])
-			r.min.y -= 1 + nl[j]*v->body.fr.font->height;
+      r.min.y -= 1 + nl[j] * v->body.fr.font->height;
     r.min.y -= Border;
     ny[j] = r.min.y;
     y2 = r.min.y;
@@ -433,31 +452,41 @@ colgrow(Column *c, Window *w, int but)
   r.min.y = y1;
   r.max.y = y2;
   h = w->body.fr.font->height;
-	if(Dy(r) < Dy(w->tagtop)+1+h+Border)
+  if (Dy(r) < Dy(w->tagtop) + 1 + h + Border)
-		r.max.y = r.min.y + Dy(w->tagtop)+1+h+Border;
+    r.max.y = r.min.y + Dy(w->tagtop) + 1 + h + Border;
   /* draw window */
   r.max.y = winresize(w, r, c->safe, TRUE);
-	if(i < c->nw-1){
+  if (i < c->nw - 1) {
     r.min.y = r.max.y;
     r.max.y += Border;
-		draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+    draw(
-		for(j=i+1; j<c->nw; j++)
+      screen,
-			ny[j] -= (y2-r.max.y);
+      r,
+      allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+      nil,
+      ZP);
+    for (j = i + 1; j < c->nw; j++)
+      ny[j] -= (y2 - r.max.y);
   }
   /* pack everyone below */
   y1 = r.max.y;
-	for(j=i+1; j<c->nw; j++){
+  for (j = i + 1; j < c->nw; j++) {
     v = c->w[j];
     r = v->r;
     r.min.y = y1;
-		r.max.y = y1+Dy(v->tagtop);
+    r.max.y = y1 + Dy(v->tagtop);
-		if(nl[j])
+    if (nl[j])
-			r.max.y += 1 + nl[j]*v->body.fr.font->height;
+      r.max.y += 1 + nl[j] * v->body.fr.font->height;
-		y1 = winresize(v, r, c->safe, j==c->nw-1);
+    y1 = winresize(v, r, c->safe, j == c->nw - 1);
-		if(j < c->nw-1){	/* no border on last window */
+    if (j < c->nw - 1) { /* no border on last window */
       r.min.y = y1;
       r.max.y += Border;
-			draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+      draw(
+        screen,
+        r,
+        allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+        nil,
+        ZP);
       y1 = r.max.y;
     }
   }
@@ -467,106 +496,108 @@ colgrow(Column *c, Window *w, int but)
   winmousebut(w);
 }
 
-void
+void coldragwin(Column* c, Window* w, int but) {
-coldragwin(Column *c, Window *w, int but)
-{
   Rectangle r;
   int i, b;
   Point p, op;
-	Window *v;
+  Window* v;
-	Column *nc;
+  Column* nc;
 
   clearmouse();
   setcursor2(mousectl, &boxcursor, &boxcursor2);
   b = mouse->buttons;
   op = mouse->xy;
-	while(mouse->buttons == b)
+  while (mouse->buttons == b)
     readmouse(mousectl);
   setcursor(mousectl, nil);
-	if(mouse->buttons){
+  if (mouse->buttons) {
-		while(mouse->buttons)
+    while (mouse->buttons)
       readmouse(mousectl);
     return;
   }
 
-	for(i=0; i<c->nw; i++)
+  for (i = 0; i < c->nw; i++)
-		if(c->w[i] == w)
+    if (c->w[i] == w)
       goto Found;
   error("can't find window");
 
-  Found:
+Found:
-	if(w->tagexpand)	/* force recomputation of window tag size */
+  if (w->tagexpand) /* force recomputation of window tag size */
     w->taglines = 1;
   p = mouse->xy;
-	if(abs(p.x-op.x)<5 && abs(p.y-op.y)<5){
+  if (abs(p.x - op.x) < 5 && abs(p.y - op.y) < 5) {
     colgrow(c, w, but);
     winmousebut(w);
     return;
   }
   /* is it a flick to the right? */
-	if(abs(p.y-op.y)<10 && p.x>op.x+30 && rowwhichcol(c->row, p)==c)
+  if (abs(p.y - op.y) < 10 && p.x > op.x + 30 && rowwhichcol(c->row, p) == c)
-		p.x = op.x+Dx(w->r);	/* yes: toss to next column */
+    p.x = op.x + Dx(w->r); /* yes: toss to next column */
   nc = rowwhichcol(c->row, p);
-	if(nc!=nil && nc!=c){
+  if (nc != nil && nc != c) {
     colclose(c, w, FALSE);
     coladd(nc, w, nil, p.y);
     winmousebut(w);
     return;
   }
-	if(i==0 && c->nw==1)
+  if (i == 0 && c->nw == 1)
     return; /* can't do it */
-	if((i>0 && p.y<c->w[i-1]->r.min.y) || (i<c->nw-1 && p.y>w->r.max.y)
+  if (
-	|| (i==0 && p.y>w->r.max.y)){
+    (i > 0 && p.y < c->w[i - 1]->r.min.y) ||
+    (i < c->nw - 1 && p.y > w->r.max.y) || (i == 0 && p.y > w->r.max.y)) {
     /* shuffle */
     colclose(c, w, FALSE);
     coladd(c, w, nil, p.y);
     winmousebut(w);
     return;
   }
-	if(i == 0)
+  if (i == 0)
     return;
-	v = c->w[i-1];
+  v = c->w[i - 1];
-	if(p.y < v->tagtop.max.y)
+  if (p.y < v->tagtop.max.y)
     p.y = v->tagtop.max.y;
-	if(p.y > w->r.max.y-Dy(w->tagtop)-Border)
+  if (p.y > w->r.max.y - Dy(w->tagtop) - Border)
-		p.y = w->r.max.y-Dy(w->tagtop)-Border;
+    p.y = w->r.max.y - Dy(w->tagtop) - Border;
   r = v->r;
   r.max.y = p.y;
-	if(r.max.y > v->body.fr.r.min.y){
+  if (r.max.y > v->body.fr.r.min.y) {
-		r.max.y -= (r.max.y-v->body.fr.r.min.y)%v->body.fr.font->height;
+    r.max.y -= (r.max.y - v->body.fr.r.min.y) % v->body.fr.font->height;
-		if(v->body.fr.r.min.y == v->body.fr.r.max.y)
+    if (v->body.fr.r.min.y == v->body.fr.r.max.y)
       r.max.y++;
   }
   r.min.y = winresize(v, r, c->safe, FALSE);
-	r.max.y = r.min.y+Border;
+  r.max.y = r.min.y + Border;
-	draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
+  draw(
+    screen,
+    r,
+    allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
+    nil,
+    ZP);
   r.min.y = r.max.y;
-	if(i == c->nw-1)
+  if (i == c->nw - 1)
     r.max.y = c->r.max.y;
   else
-		r.max.y = c->w[i+1]->r.min.y-Border;
+    r.max.y = c->w[i + 1]->r.min.y - Border;
   winresize(w, r, c->safe, TRUE);
   c->safe = TRUE;
   winmousebut(w);
 }
 
-Text*
+Text* colwhich(Column* c, Point p) {
-colwhich(Column *c, Point p)
-{
   int i;
-	Window *w;
+  Window* w;
 
-	if(!ptinrect(p, c->r))
+  if (!ptinrect(p, c->r))
     return nil;
-	if(ptinrect(p, c->tag.all))
+  if (ptinrect(p, c->tag.all))
     return &c->tag;
-	for(i=0; i<c->nw; i++){
+  for (i = 0; i < c->nw; i++) {
     w = c->w[i];
-		if(ptinrect(p, w->r)){
+    if (ptinrect(p, w->r)) {
-			if(ptinrect(p, w->tagtop) || ptinrect(p, w->tag.all))
+      if (ptinrect(p, w->tagtop) || ptinrect(p, w->tag.all))
         return &w->tag;
       /* exclude partial line at bottom */
-			if(p.x >= w->body.scrollr.max.x && p.y >= w->body.fr.r.max.y)
+      if (p.x >= w->body.scrollr.max.x && p.y >= w->body.fr.r.max.y)
         return nil;
       return &w->body;
     }
@@ -574,13 +605,11 @@ colwhich(Column *c, Point p)
   return nil;
 }
 
-int
+int colclean(Column* c) {
-colclean(Column *c)
-{
   int i, clean;
 
   clean = TRUE;
-	for(i=0; i<c->nw; i++)
+  for (i = 0; i < c->nw; i++)
     clean &= winclean(c->w[i], TRUE);
   return clean;
 }

disk.c

@@ -12,78 +12,69 @@
 #include "dat.h"
 #include "fns.h"
 
-static	Block	*blist;
+static Block* blist;
 
-int
+int tempfile(void) {
-tempfile(void)
-{
   char buf[128];
   int i, fd;
 
   snprint(buf, sizeof buf, "/tmp/X%d.%.4sacme", getpid(), getuser());
-	for(i='A'; i<='Z'; i++){
+  for (i = 'A'; i <= 'Z'; i++) {
     buf[5] = i;
-		if(access(buf, AEXIST) == 0)
+    if (access(buf, AEXIST) == 0)
       continue;
-		fd = create(buf, ORDWR|ORCLOSE|OCEXEC, 0600);
+    fd = create(buf, ORDWR | ORCLOSE | OCEXEC, 0600);
-		if(fd >= 0)
+    if (fd >= 0)
       return fd;
   }
   return -1;
 }
 
-Disk*
+Disk* diskinit() {
-diskinit()
+  Disk* d;
-{
-	Disk *d;
 
   d = emalloc(sizeof(Disk));
   d->fd = tempfile();
-	if(d->fd < 0){
+  if (d->fd < 0) {
     fprint(2, "acme: can't create temp file: %r\n");
     threadexitsall("diskinit");
   }
   return d;
 }
 
-static
+static uint ntosize(uint n, uint* ip) {
-uint
-ntosize(uint n, uint *ip)
-{
   uint size;
 
-	if(n > Maxblock)
+  if (n > Maxblock)
     error("internal error: ntosize");
   size = n;
-	if(size & (Blockincr-1))
+  if (size & (Blockincr - 1))
-		size += Blockincr - (size & (Blockincr-1));
+    size += Blockincr - (size & (Blockincr - 1));
   /* last bucket holds blocks of exactly Maxblock */
-	if(ip)
+  if (ip)
-		*ip = size/Blockincr;
+    *ip = size / Blockincr;
   return size * sizeof(Rune);
 }
 
-Block*
+Block* disknewblock(Disk* d, uint n) {
-disknewblock(Disk *d, uint n)
-{
   uint i, j, size;
-	Block *b;
+  Block* b;
 
   size = ntosize(n, &i);
   b = d->free[i];
-	if(b)
+  if (b)
     d->free[i] = b->u.next;
-	else{
+  else {
     /* allocate in chunks to reduce malloc overhead */
-		if(blist == nil){
+    if (blist == nil) {
-			blist = emalloc(100*sizeof(Block));
+      blist = emalloc(100 * sizeof(Block));
-			for(j=0; j<100-1; j++)
+      for (j = 0; j < 100 - 1; j++)
-				blist[j].u.next = &blist[j+1];
+        blist[j].u.next = &blist[j + 1];
     }
     b = blist;
     blist = b->u.next;
     b->addr = d->addr;
-		if(d->addr+size < d->addr){
+    if (d->addr + size < d->addr) {
       error("temp file overflow");
     }
     d->addr += size;
@@ -92,9 +83,7 @@ disknewblock(Disk *d, uint n)
   return b;
 }
 
-void
+void diskrelease(Disk* d, Block* b) {
-diskrelease(Disk *d, Block *b)
-{
   uint i;
 
   ntosize(b->u.n, &i);
@@ -102,32 +91,28 @@ diskrelease(Disk *d, Block *b)
   d->free[i] = b;
 }
 
-void
+void diskwrite(Disk* d, Block** bp, Rune* r, uint n) {
-diskwrite(Disk *d, Block **bp, Rune *r, uint n)
-{
   int size, nsize;
-	Block *b;
+  Block* b;
 
   b = *bp;
   size = ntosize(b->u.n, nil);
   nsize = ntosize(n, nil);
-	if(size != nsize){
+  if (size != nsize) {
     diskrelease(d, b);
     b = disknewblock(d, n);
     *bp = b;
   }
-	if(pwrite(d->fd, r, n*sizeof(Rune), b->addr) != n*sizeof(Rune))
+  if (pwrite(d->fd, r, n * sizeof(Rune), b->addr) != n * sizeof(Rune))
     error("write error to temp file");
   b->u.n = n;
 }
 
-void
+void diskread(Disk* d, Block* b, Rune* r, uint n) {
-diskread(Disk *d, Block *b, Rune *r, uint n)
+  if (n > b->u.n)
-{
-	if(n > b->u.n)
     error("internal error: diskread");
 
   ntosize(b->u.n, nil);
-	if(pread(d->fd, r, n*sizeof(Rune), b->addr) != n*sizeof(Rune))
+  if (pread(d->fd, r, n * sizeof(Rune), b->addr) != n * sizeof(Rune))
     error("read error from temp file");
 }

elog.c

@@ -27,65 +27,52 @@ static int	warned = FALSE;
  */
 
 typedef struct Buflog Buflog;
-struct Buflog
+struct Buflog {
-{
   short type; /* Replace, Filename */
   uint q0;    /* location of change (unused in f) */
   uint nd;    /* # runes to delete */
   uint nr;    /* # runes in string or file name */
 };
 
-enum
+enum { Buflogsize = sizeof(Buflog) / sizeof(Rune) };
-{
-	Buflogsize = sizeof(Buflog)/sizeof(Rune)
-};
 
 /*
  * Minstring shouldn't be very big or we will do lots of I/O for small changes.
  * Maxstring is RBUFSIZE so we can fbufalloc() once and not realloc elog.r.
  */
-enum
+enum {
-{
   Minstring = 16,      /* distance beneath which we merge changes */
   Maxstring = RBUFSIZE /* maximum length of change we will merge into one */
 };
 
-void
+void eloginit(File* f) {
-eloginit(File *f)
+  if (f->elog.type != Empty)
-{
-	if(f->elog.type != Empty)
     return;
   f->elog.type = Null;
-	if(f->elogbuf == nil)
+  if (f->elogbuf == nil)
     f->elogbuf = emalloc(sizeof(Buffer));
-	if(f->elog.r == nil)
+  if (f->elog.r == nil)
     f->elog.r = fbufalloc();
   bufreset(f->elogbuf);
 }
 
-void
+void elogclose(File* f) {
-elogclose(File *f)
+  if (f->elogbuf) {
-{
-	if(f->elogbuf){
     bufclose(f->elogbuf);
     free(f->elogbuf);
     f->elogbuf = nil;
   }
 }
 
-void
+void elogreset(File* f) {
-elogreset(File *f)
-{
   f->elog.type = Null;
   f->elog.nd = 0;
   f->elog.nr = 0;
 }
 
-void
+void elogterm(File* f) {
-elogterm(File *f)
-{
   elogreset(f);
-	if(f->elogbuf)
+  if (f->elogbuf)
     bufreset(f->elogbuf);
   f->elog.type = Empty;
   fbuffree(f->elog.r);
@@ -93,16 +80,14 @@ elogterm(File *f)
   warned = FALSE;
 }
 
-void
+void elogflush(File* f) {
-elogflush(File *f)
-{
   Buflog b;
 
   b.type = f->elog.type;
   b.q0 = f->elog.q0;
   b.nd = f->elog.nd;
   b.nr = f->elog.nr;
-	switch(f->elog.type){
+  switch (f->elog.type) {
     default:
       warning(nil, "unknown elog type 0x%ux\n", f->elog.type);
       break;
@@ -110,7 +95,7 @@ elogflush(File *f)
       break;
     case Insert:
     case Replace:
-		if(f->elog.nr > 0)
+      if (f->elog.nr > 0)
         bufinsert(f->elogbuf, f->elogbuf->nc, f->elog.r, f->elog.nr);
       /* fall through */
     case Delete:
@@ -120,29 +105,27 @@ elogflush(File *f)
   elogreset(f);
 }
 
-void
+void elogreplace(File* f, int q0, int q1, Rune* r, int nr) {
-elogreplace(File *f, int q0, int q1, Rune *r, int nr)
-{
   uint gap;
 
-	if(q0==q1 && nr==0)
+  if (q0 == q1 && nr == 0)
     return;
   eloginit(f);
-	if(f->elog.type!=Null && q0<f->elog.q0){
+  if (f->elog.type != Null && q0 < f->elog.q0) {
-		if(warned++ == 0)
+    if (warned++ == 0)
       warning(nil, Wsequence);
     elogflush(f);
   }
   /* try to merge with previous */
-	gap = q0 - (f->elog.q0+f->elog.nd);	/* gap between previous and this */
+  gap = q0 - (f->elog.q0 + f->elog.nd); /* gap between previous and this */
-	if(f->elog.type==Replace && f->elog.nr+gap+nr<Maxstring){
+  if (f->elog.type == Replace && f->elog.nr + gap + nr < Maxstring) {
-		if(gap < Minstring){
+    if (gap < Minstring) {
-			if(gap > 0){
+      if (gap > 0) {
-				bufread(&f->b, f->elog.q0+f->elog.nd, f->elog.r+f->elog.nr, gap);
+        bufread(&f->b, f->elog.q0 + f->elog.nd, f->elog.r + f->elog.nr, gap);
         f->elog.nr += gap;
       }
-			f->elog.nd += gap + q1-q0;
+      f->elog.nd += gap + q1 - q0;
-			runemove(f->elog.r+f->elog.nr, r, nr);
+      runemove(f->elog.r + f->elog.nr, r, nr);
       f->elog.nr += nr;
       return;
     }
@@ -150,38 +133,37 @@ elogreplace(File *f, int q0, int q1, Rune *r, int nr)
   elogflush(f);
   f->elog.type = Replace;
   f->elog.q0 = q0;
-	f->elog.nd = q1-q0;
+  f->elog.nd = q1 - q0;
   f->elog.nr = nr;
-	if(nr > RBUFSIZE)
+  if (nr > RBUFSIZE)
     editerror("internal error: replacement string too large(%d)", nr);
   runemove(f->elog.r, r, nr);
 }
 
-void
+void eloginsert(File* f, int q0, Rune* r, int nr) {
-eloginsert(File *f, int q0, Rune *r, int nr)
-{
   int n;
 
-	if(nr == 0)
+  if (nr == 0)
     return;
   eloginit(f);
-	if(f->elog.type!=Null && q0<f->elog.q0){
+  if (f->elog.type != Null && q0 < f->elog.q0) {
-		if(warned++ == 0)
+    if (warned++ == 0)
       warning(nil, Wsequence);
     elogflush(f);
   }
   /* try to merge with previous */
-	if(f->elog.type==Insert && q0==f->elog.q0 && f->elog.nr+nr<Maxstring){
+  if (
-		runemove(f->elog.r+f->elog.nr, r, nr);
+    f->elog.type == Insert && q0 == f->elog.q0 && f->elog.nr + nr < Maxstring) {
+    runemove(f->elog.r + f->elog.nr, r, nr);
     f->elog.nr += nr;
     return;
   }
-	while(nr > 0){
+  while (nr > 0) {
     elogflush(f);
     f->elog.type = Insert;
     f->elog.q0 = q0;
     n = nr;
-		if(n > RBUFSIZE)
+    if (n > RBUFSIZE)
       n = RBUFSIZE;
     f->elog.nr = n;
     runemove(f->elog.r, r, n);
@@ -190,38 +172,34 @@ eloginsert(File *f, int q0, Rune *r, int nr)
   }
 }
 
-void
+void elogdelete(File* f, int q0, int q1) {
-elogdelete(File *f, int q0, int q1)
+  if (q0 == q1)
-{
-	if(q0 == q1)
     return;
   eloginit(f);
-	if(f->elog.type!=Null && q0<f->elog.q0+f->elog.nd){
+  if (f->elog.type != Null && q0 < f->elog.q0 + f->elog.nd) {
-		if(warned++ == 0)
+    if (warned++ == 0)
       warning(nil, Wsequence);
     elogflush(f);
   }
   /* try to merge with previous */
-	if(f->elog.type==Delete && f->elog.q0+f->elog.nd==q0){
+  if (f->elog.type == Delete && f->elog.q0 + f->elog.nd == q0) {
-		f->elog.nd += q1-q0;
+    f->elog.nd += q1 - q0;
     return;
   }
   elogflush(f);
   f->elog.type = Delete;
   f->elog.q0 = q0;
-	f->elog.nd = q1-q0;
+  f->elog.nd = q1 - q0;
 }
 
 #define tracelog 0
-void
+void elogapply(File* f) {
-elogapply(File *f)
-{
   Buflog b;
-	Rune *buf;
+  Rune* buf;
   uint i, n, up, mod;
   uint tq0, tq1;
-	Buffer *log;
+  Buffer* log;
-	Text *t;
+  Text* t;
   int owner;
 
   elogflush(f);
@@ -232,19 +210,19 @@ elogapply(File *f)
   mod = FALSE;
 
   owner = 0;
-	if(t->w){
+  if (t->w) {
     owner = t->w->owner;
-		if(owner == 0)
+    if (owner == 0)
       t->w->owner = 'E';
   }
 
   /*
    * The edit commands have already updated the selection in t->q0, t->q1,
-	 * but using coordinates relative to the unmodified buffer.  As we apply the log,
+   * but using coordinates relative to the unmodified buffer.  As we apply the
-	 * we have to update the coordinates to be relative to the modified buffer.
+   * log, we have to update the coordinates to be relative to the modified
-	 * Textinsert and textdelete will do this for us; our only work is to apply the
+   * buffer. Textinsert and textdelete will do this for us; our only work is to
-	 * convention that an insertion at t->q0==t->q1 is intended to select the 
+   * apply the convention that an insertion at t->q0==t->q1 is intended to
-	 * inserted text.
+   * select the inserted text.
    */
 
   /*
@@ -254,71 +232,86 @@ elogapply(File *f)
    * keep things in range.
    */
 
-	while(log->nc > 0){
+  while (log->nc > 0) {
-		up = log->nc-Buflogsize;
+    up = log->nc - Buflogsize;
     bufread(log, up, (Rune*)&b, Buflogsize);
-		switch(b.type){
+    switch (b.type) {
       default:
         fprint(2, "elogapply: 0x%ux\n", b.type);
         abort();
         break;
 
       case Replace:
-			if(tracelog)
+        if (tracelog)
-				warning(nil, "elog replace %d %d (%d %d)\n",
+          warning(
-					b.q0, b.q0+b.nd, t->q0, t->q1);
+            nil,
-			if(!mod){
+            "elog replace %d %d (%d %d)\n",
+            b.q0,
+            b.q0 + b.nd,
+            t->q0,
+            t->q1);
+        if (!mod) {
           mod = TRUE;
           filemark(f);
         }
-			textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
+        textconstrain(t, b.q0, b.q0 + b.nd, &tq0, &tq1);
         textdelete(t, tq0, tq1, TRUE);
         up -= b.nr;
-			for(i=0; i<b.nr; i+=n){
+        for (i = 0; i < b.nr; i += n) {
           n = b.nr - i;
-				if(n > RBUFSIZE)
+          if (n > RBUFSIZE)
             n = RBUFSIZE;
-				bufread(log, up+i, buf, n);
+          bufread(log, up + i, buf, n);
-				textinsert(t, tq0+i, buf, n, TRUE);
+          textinsert(t, tq0 + i, buf, n, TRUE);
         }
-			if(t->q0 == b.q0 && t->q1 == b.q0)
+        if (t->q0 == b.q0 && t->q1 == b.q0)
           t->q1 += b.nr;
         break;
 
       case Delete:
-			if(tracelog)
+        if (tracelog)
-				warning(nil, "elog delete %d %d (%d %d)\n",
+          warning(
-					b.q0, b.q0+b.nd, t->q0, t->q1);
+            nil,
-			if(!mod){
+            "elog delete %d %d (%d %d)\n",
+            b.q0,
+            b.q0 + b.nd,
+            t->q0,
+            t->q1);
+        if (!mod) {
           mod = TRUE;
           filemark(f);
         }
-			textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
+        textconstrain(t, b.q0, b.q0 + b.nd, &tq0, &tq1);
         textdelete(t, tq0, tq1, TRUE);
         break;
 
       case Insert:
-			if(tracelog)
+        if (tracelog)
-				warning(nil, "elog insert %d %d (%d %d)\n",
+          warning(
-					b.q0, b.q0+b.nr, t->q0, t->q1);
+            nil,
-			if(!mod){
+            "elog insert %d %d (%d %d)\n",
+            b.q0,
+            b.q0 + b.nr,
+            t->q0,
+            t->q1);
+        if (!mod) {
           mod = TRUE;
           filemark(f);
         }
         textconstrain(t, b.q0, b.q0, &tq0, &tq1);
         up -= b.nr;
-			for(i=0; i<b.nr; i+=n){
+        for (i = 0; i < b.nr; i += n) {
           n = b.nr - i;
-				if(n > RBUFSIZE)
+          if (n > RBUFSIZE)
             n = RBUFSIZE;
-				bufread(log, up+i, buf, n);
+          bufread(log, up + i, buf, n);
-				textinsert(t, tq0+i, buf, n, TRUE);
+          textinsert(t, tq0 + i, buf, n, TRUE);
         }
-			if(t->q0 == b.q0 && t->q1 == b.q0)
+        if (t->q0 == b.q0 && t->q1 == b.q0)
           t->q1 += b.nr;
         break;
 
-/*		case Filename:
+        /*		case Filename:
               f->seq = u.seq;
               fileunsetname(f, epsilon);
               f->mod = u.mod;
@@ -331,7 +324,7 @@ elogapply(File *f)
               bufread(delta, up, f->name, u.n);
               f->nname = u.n;
               break;
-*/
+        */
     }
     bufdelete(log, up, log->nc);
   }
@@ -342,13 +335,13 @@ elogapply(File *f)
    * Bad addresses will cause bufload to crash, so double check.
    * If changes were out of order, we expect problems so don't complain further.
    */
-	if(t->q0 > f->b.nc || t->q1 > f->b.nc || t->q0 > t->q1){
+  if (t->q0 > f->b.nc || t->q1 > f->b.nc || t->q0 > t->q1) {
-		if(!warned)
+    if (!warned)
       warning(nil, "elogapply: can't happen %d %d %d\n", t->q0, t->q1, f->b.nc);
     t->q1 = min(t->q1, f->b.nc);
     t->q0 = min(t->q0, t->q1);
   }
 
-	if(t->w)
+  if (t->w)
     t->w->owner = owner;
 }

file.c

@@ -23,8 +23,7 @@
  */
 
 typedef struct Undo Undo;
-struct Undo
+struct Undo {
-{
   short type; /* Delete, Insert, Filename */
   short mod;  /* modify bit */
   uint seq;   /* sequence number */
@@ -32,60 +31,49 @@ struct Undo
   uint n;     /* # runes in string or file name */
 };
 
-enum
+enum { Undosize = sizeof(Undo) / sizeof(Rune) };
-{
-	Undosize = sizeof(Undo)/sizeof(Rune)
-};
 
-File*
+File* fileaddtext(File* f, Text* t) {
-fileaddtext(File *f, Text *t)
+  if (f == nil) {
-{
-	if(f == nil){
     f = emalloc(sizeof(File));
     f->unread = TRUE;
   }
-	f->text = realloc(f->text, (f->ntext+1)*sizeof(Text*));
+  f->text = realloc(f->text, (f->ntext + 1) * sizeof(Text*));
   f->text[f->ntext++] = t;
   f->curtext = t;
   return f;
 }
 
-void
+void filedeltext(File* f, Text* t) {
-filedeltext(File *f, Text *t)
-{
   int i;
 
-	for(i=0; i<f->ntext; i++)
+  for (i = 0; i < f->ntext; i++)
-		if(f->text[i] == t)
+    if (f->text[i] == t)
       goto Found;
   error("can't find text in filedeltext");
 
-    Found:
+Found:
   f->ntext--;
-	if(f->ntext == 0){
+  if (f->ntext == 0) {
     fileclose(f);
     return;
   }
-	memmove(f->text+i, f->text+i+1, (f->ntext-i)*sizeof(Text*));
+  memmove(f->text + i, f->text + i + 1, (f->ntext - i) * sizeof(Text*));
-	if(f->curtext == t)
+  if (f->curtext == t)
     f->curtext = f->text[0];
 }
 
-void
+void fileinsert(File* f, uint p0, Rune* s, uint ns) {
-fileinsert(File *f, uint p0, Rune *s, uint ns)
+  if (p0 > f->b.nc)
-{
-	if(p0 > f->b.nc)
     error("internal error: fileinsert");
-	if(f->seq > 0)
+  if (f->seq > 0)
     fileuninsert(f, &f->delta, p0, ns);
   bufinsert(&f->b, p0, s, ns);
-	if(ns)
+  if (ns)
     f->mod = TRUE;
 }
 
-void
+void fileuninsert(File* f, Buffer* delta, uint p0, uint ns) {
-fileuninsert(File *f, Buffer *delta, uint p0, uint ns)
-{
   Undo u;
 
   /* undo an insertion by deleting */
@@ -97,23 +85,19 @@ fileuninsert(File *f, Buffer *delta, uint p0, uint ns)
   bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
 }
 
-void
+void filedelete(File* f, uint p0, uint p1) {
-filedelete(File *f, uint p0, uint p1)
+  if (!(p0 <= p1 && p0 <= f->b.nc && p1 <= f->b.nc))
-{
-	if(!(p0<=p1 && p0<=f->b.nc && p1<=f->b.nc))
     error("internal error: filedelete");
-	if(f->seq > 0)
+  if (f->seq > 0)
     fileundelete(f, &f->delta, p0, p1);
   bufdelete(&f->b, p0, p1);
-	if(p1 > p0)
+  if (p1 > p0)
     f->mod = TRUE;
 }
 
-void
+void fileundelete(File* f, Buffer* delta, uint p0, uint p1) {
-fileundelete(File *f, Buffer *delta, uint p0, uint p1)
-{
   Undo u;
-	Rune *buf;
+  Rune* buf;
   uint i, n;
 
   /* undo a deletion by inserting */
@@ -121,24 +105,21 @@ fileundelete(File *f, Buffer *delta, uint p0, uint p1)
   u.mod = f->mod;
   u.seq = f->seq;
   u.p0 = p0;
-	u.n = p1-p0;
+  u.n = p1 - p0;
   buf = fbufalloc();
-	for(i=p0; i<p1; i+=n){
+  for (i = p0; i < p1; i += n) {
     n = p1 - i;
-		if(n > RBUFSIZE)
+    if (n > RBUFSIZE)
       n = RBUFSIZE;
     bufread(&f->b, i, buf, n);
     bufinsert(delta, delta->nc, buf, n);
   }
   fbuffree(buf);
   bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
-
 }
 
-void
+void filesetname(File* f, Rune* name, int n) {
-filesetname(File *f, Rune *name, int n)
+  if (f->seq > 0)
-{
-	if(f->seq > 0)
     fileunsetname(f, &f->delta);
   free(f->name);
   f->name = runemalloc(n);
@@ -147,9 +128,7 @@ filesetname(File *f, Rune *name, int n)
   f->unread = TRUE;
 }
 
-void
+void fileunsetname(File* f, Buffer* delta) {
-fileunsetname(File *f, Buffer *delta)
-{
   Undo u;
 
   /* undo a file name change by restoring old name */
@@ -158,48 +137,42 @@ fileunsetname(File *f, Buffer *delta)
   u.seq = f->seq;
   u.p0 = 0; /* unused */
   u.n = f->nname;
-	if(f->nname)
+  if (f->nname)
     bufinsert(delta, delta->nc, f->name, f->nname);
   bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
 }
 
-uint
+uint fileload(File* f, uint p0, int fd, int* nulls, DigestState* h) {
-fileload(File *f, uint p0, int fd, int *nulls, DigestState *h)
+  if (f->seq > 0)
-{
-	if(f->seq > 0)
     error("undo in file.load unimplemented");
   return bufload(&f->b, p0, fd, nulls, h);
 }
 
 /* return sequence number of pending redo */
-uint
+uint fileredoseq(File* f) {
-fileredoseq(File *f)
-{
   Undo u;
-	Buffer *delta;
+  Buffer* delta;
 
   delta = &f->epsilon;
-	if(delta->nc == 0)
+  if (delta->nc == 0)
     return 0;
-	bufread(delta, delta->nc-Undosize, (Rune*)&u, Undosize);
+  bufread(delta, delta->nc - Undosize, (Rune*)&u, Undosize);
   return u.seq;
 }
 
-void
+void fileundo(File* f, int isundo, uint* q0p, uint* q1p) {
-fileundo(File *f, int isundo, uint *q0p, uint *q1p)
-{
   Undo u;
-	Rune *buf;
+  Rune* buf;
   uint i, j, n, up;
   uint stop;
   Buffer *delta, *epsilon;
 
-	if(isundo){
+  if (isundo) {
     /* undo; reverse delta onto epsilon, seq decreases */
     delta = &f->delta;
     epsilon = &f->epsilon;
     stop = f->seq;
-	}else{
+  } else {
     /* redo; reverse epsilon onto delta, seq increases */
     delta = &f->epsilon;
     epsilon = &f->delta;
@@ -207,21 +180,21 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
   }
 
   buf = fbufalloc();
-	while(delta->nc > 0){
+  while (delta->nc > 0) {
-		up = delta->nc-Undosize;
+    up = delta->nc - Undosize;
     bufread(delta, up, (Rune*)&u, Undosize);
-		if(isundo){
+    if (isundo) {
-			if(u.seq < stop){
+      if (u.seq < stop) {
         f->seq = u.seq;
         goto Return;
       }
-		}else{
+    } else {
-			if(stop == 0)
+      if (stop == 0)
         stop = u.seq;
-			if(u.seq > stop)
+      if (u.seq > stop)
         goto Return;
     }
-		switch(u.type){
+    switch (u.type) {
       default:
         fprint(2, "undo: 0x%ux\n", u.type);
         abort();
@@ -229,11 +202,11 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
 
       case Delete:
         f->seq = u.seq;
-			fileundelete(f, epsilon, u.p0, u.p0+u.n);
+        fileundelete(f, epsilon, u.p0, u.p0 + u.n);
         f->mod = u.mod;
-			bufdelete(&f->b, u.p0, u.p0+u.n);
+        bufdelete(&f->b, u.p0, u.p0 + u.n);
-			for(j=0; j<f->ntext; j++)
+        for (j = 0; j < f->ntext; j++)
-				textdelete(f->text[j], u.p0, u.p0+u.n, FALSE);
+          textdelete(f->text[j], u.p0, u.p0 + u.n, FALSE);
         *q0p = u.p0;
         *q1p = u.p0;
         break;
@@ -243,17 +216,17 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
         fileuninsert(f, epsilon, u.p0, u.n);
         f->mod = u.mod;
         up -= u.n;
-			for(i=0; i<u.n; i+=n){
+        for (i = 0; i < u.n; i += n) {
           n = u.n - i;
-				if(n > RBUFSIZE)
+          if (n > RBUFSIZE)
             n = RBUFSIZE;
-				bufread(delta, up+i, buf, n);
+          bufread(delta, up + i, buf, n);
-				bufinsert(&f->b, u.p0+i, buf, n);
+          bufinsert(&f->b, u.p0 + i, buf, n);
-				for(j=0; j<f->ntext; j++)
+          for (j = 0; j < f->ntext; j++)
-					textinsert(f->text[j], u.p0+i, buf, n, FALSE);
+            textinsert(f->text[j], u.p0 + i, buf, n, FALSE);
         }
         *q0p = u.p0;
-			*q1p = u.p0+u.n;
+        *q1p = u.p0 + u.n;
         break;
 
       case Filename:
@@ -262,7 +235,7 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
         f->mod = u.mod;
         up -= u.n;
         free(f->name);
-			if(u.n == 0)
+        if (u.n == 0)
           f->name = nil;
         else
           f->name = runemalloc(u.n);
@@ -272,23 +245,19 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
     }
     bufdelete(delta, up, delta->nc);
   }
-	if(isundo)
+  if (isundo)
     f->seq = 0;
-    Return:
+Return:
   fbuffree(buf);
 }
 
-void
+void filereset(File* f) {
-filereset(File *f)
-{
   bufreset(&f->delta);
   bufreset(&f->epsilon);
   f->seq = 0;
 }
 
-void
+void fileclose(File* f) {
-fileclose(File *f)
-{
   free(f->name);
   f->nname = 0;
   f->name = nil;
@@ -302,10 +271,8 @@ fileclose(File *f)
   free(f);
 }
 
-void
+void filemark(File* f) {
-filemark(File *f)
+  if (f->epsilon.nc)
-{
-	if(f->epsilon.nc)
     bufdelete(&f->epsilon, 0, f->epsilon.nc);
   f->seq = seq;
 }

fns.h

@@ -95,6 +95,7 @@ void		flushwarnings(void);
 void		startplumbing(void);
 long	nlcount(Text*, long, long, long*);
 long	nlcounttopos(Text*, long, long, long);
+Rune* parsetag(Window*, int*);
 
 Runestr	runestr(Rune*, uint);
 Range range(int, int);

fsys.c

@@ -14,15 +14,11 @@
 
 static int sfd;
 
-enum
+enum { Nhash = 16, DEBUG = 0 };
-{
-	Nhash	= 16,
-	DEBUG	= 0
-};
 
-static	Fid	*fids[Nhash];
+static Fid* fids[Nhash];
 
-Fid	*newfid(int);
+Fid* newfid(int);
 
 static Xfid* fsysflush(Xfid*, Fid*);
 static Xfid* fsysauth(Xfid*, Fid*);
@@ -40,9 +36,7 @@ static	Xfid*	fsyswstat(Xfid*, Fid*);
 
 Xfid* (*fcall[Tmax])(Xfid*, Fid*);
 
-static void
+static void initfcall(void) {
-initfcall(void)
-{
   fcall[Tflush] = fsysflush;
   fcall[Tversion] = fsysversion;
   fcall[Tauth] = fsysauth;
@@ -53,7 +47,7 @@ initfcall(void)
   fcall[Tread] = fsysread;
   fcall[Twrite] = fsyswrite;
   fcall[Tclunk] = fsysclunk;
-	fcall[Tremove]= fsysremove;
+  fcall[Tremove] = fsysremove;
   fcall[Tstat] = fsysstat;
   fcall[Twstat] = fsyswstat;
 }
@@ -62,44 +56,46 @@ char Eperm[] = "permission denied";
 char Eexist[] = "file does not exist";
 char Enotdir[] = "not a directory";
 
-Dirtab dirtab[]=
+Dirtab dirtab[] = {
-{
+  {".", QTDIR, Qdir, 0500 | DMDIR},
-	{ ".",			QTDIR,	Qdir,		0500|DMDIR },
+  {"acme", QTDIR, Qacme, 0500 | DMDIR},
-	{ "acme",		QTDIR,	Qacme,	0500|DMDIR },
+  {"cons", QTFILE, Qcons, 0600},
-	{ "cons",		QTFILE,	Qcons,	0600 },
+  {"consctl", QTFILE, Qconsctl, 0000},
-	{ "consctl",	QTFILE,	Qconsctl,	0000 },
+  {"draw",
-	{ "draw",		QTDIR,	Qdraw,	0000|DMDIR },	/* to suppress graphics progs started in acme */
+   QTDIR,
-	{ "editout",	QTFILE,	Qeditout,	0200 },
+   Qdraw,
-	{ "index",		QTFILE,	Qindex,	0400 },
+   0000 | DMDIR}, /* to suppress graphics progs started in acme */
-	{ "label",		QTFILE,	Qlabel,	0600 },
+  {"editout", QTFILE, Qeditout, 0200},
-	{ "log",		QTFILE,	Qlog,	0400 },
+  {"index", QTFILE, Qindex, 0400},
-	{ "new",		QTDIR,	Qnew,	0500|DMDIR },
+  {"label", QTFILE, Qlabel, 0600},
-	{ nil, }
+  {"log", QTFILE, Qlog, 0400},
-};
+  {"new", QTDIR, Qnew, 0500 | DMDIR},
+  {
+    nil,
+  }};
 
-Dirtab dirtabw[]=
+Dirtab dirtabw[] = {
-{
+  {".", QTDIR, Qdir, 0500 | DMDIR},
-	{ ".",			QTDIR,		Qdir,			0500|DMDIR },
+  {"addr", QTFILE, QWaddr, 0600},
-	{ "addr",		QTFILE,		QWaddr,		0600 },
+  {"body", QTAPPEND, QWbody, 0600 | DMAPPEND},
-	{ "body",		QTAPPEND,	QWbody,		0600|DMAPPEND },
+  {"ctl", QTFILE, QWctl, 0600},
-	{ "ctl",		QTFILE,		QWctl,		0600 },
+  {"data", QTFILE, QWdata, 0600},
-	{ "data",		QTFILE,		QWdata,		0600 },
+  {"editout", QTFILE, QWeditout, 0200},
-	{ "editout",	QTFILE,		QWeditout,	0200 },
+  {"errors", QTFILE, QWerrors, 0200},
-	{ "errors",		QTFILE,		QWerrors,		0200 },
+  {"event", QTFILE, QWevent, 0600},
-	{ "event",		QTFILE,		QWevent,		0600 },
+  {"rdsel", QTFILE, QWrdsel, 0400},
-	{ "rdsel",		QTFILE,		QWrdsel,		0400 },
+  {"wrsel", QTFILE, QWwrsel, 0200},
-	{ "wrsel",		QTFILE,		QWwrsel,		0200 },
+  {"tag", QTAPPEND, QWtag, 0600 | DMAPPEND},
-	{ "tag",		QTAPPEND,	QWtag,		0600|DMAPPEND },
+  {"xdata", QTFILE, QWxdata, 0600},
-	{ "xdata",		QTFILE,		QWxdata,		0600 },
+  {
-	{ nil, }
+    nil,
-};
+  }};
 
 typedef struct Mnt Mnt;
-struct Mnt
+struct Mnt {
-{
   QLock lk;
   int id;
-	Mntdir	*md;
+  Mntdir* md;
 };
 
 Mnt mnt;
@@ -108,64 +104,62 @@ Xfid*	respond(Xfid*, Fcall*, char*);
 int dostat(int, Dirtab*, uchar*, int, uint);
 uint getclock(void);
 
-char	*user = "Wile E. Coyote";
+char* user = "Wile E. Coyote";
 static int closing = 0;
-int	messagesize = Maxblock+IOHDRSZ;	/* good start */
+int messagesize = Maxblock + IOHDRSZ; /* good start */
 
-void	fsysproc(void *);
+void fsysproc(void*);
 
-void
+void fsysinit(void) {
-fsysinit(void)
-{
   int p[2];
-	char *u;
+  char* u;
 
   initfcall();
-	if(pipe(p) < 0)
+  if (pipe(p) < 0)
     error("can't create pipe");
-	if(post9pservice(p[0], "acme", mtpt) < 0)
+  if (post9pservice(p[0], "acme", mtpt) < 0)
     error("can't post service");
   sfd = p[1];
   fmtinstall('F', fcallfmt);
-	if((u = getuser()) != nil)
+  if ((u = getuser()) != nil)
     user = estrdup(u);
   proccreate(fsysproc, nil, STACK);
 }
 
-void
+void fsysproc(void* v) {
-fsysproc(void *v)
-{
   int n;
-	Xfid *x;
+  Xfid* x;
-	Fid *f;
+  Fid* f;
   Fcall t;
-	uchar *buf;
+  uchar* buf;
 
   threadsetname("fsysproc");
 
   USED(v);
   x = nil;
-	for(;;){
+  for (;;) {
-		buf = emalloc(messagesize+UTFmax);	/* overflow for appending partial rune in xfidwrite */
+    buf = emalloc(
+      messagesize +
+      UTFmax); /* overflow for appending partial rune in xfidwrite */
     n = read9pmsg(sfd, buf, messagesize);
-		if(n <= 0){
+    if (n <= 0) {
-			if(closing)
+      if (closing)
         break;
       error("i/o error on server channel");
     }
-		if(x == nil){
+    if (x == nil) {
       sendp(cxfidalloc, nil);
       x = recvp(cxfidalloc);
     }
     x->buf = buf;
-		if(convM2S(buf, n, &x->fcall) != n)
+    if (convM2S(buf, n, &x->fcall) != n)
       error("convert error in convM2S");
-		if(DEBUG)
+    if (DEBUG)
       fprint(2, "%F\n", &x->fcall);
-		if(fcall[x->fcall.type] == nil)
+    if (fcall[x->fcall.type] == nil)
       x = respond(x, &t, "bad fcall type");
-		else{
+    else {
-			switch(x->fcall.type){
+      switch (x->fcall.type) {
         case Tversion:
         case Tauth:
         case Tflush:
@@ -176,7 +170,7 @@ fsysproc(void *v)
           break;
         default:
           f = newfid(x->fcall.fid);
-				if(!f->busy){
+          if (!f->busy) {
             x->f = f;
             x = respond(x, &t, "fid not in use");
             continue;
@@ -189,10 +183,8 @@ fsysproc(void *v)
   }
 }
 
-Mntdir*
+Mntdir* fsysaddid(Rune* dir, int ndir, Rune** incl, int nincl) {
-fsysaddid(Rune *dir, int ndir, Rune **incl, int nincl)
+  Mntdir* m;
-{
-	Mntdir *m;
   int id;
 
   qlock(&mnt.lk);
@@ -210,36 +202,32 @@ fsysaddid(Rune *dir, int ndir, Rune **incl, int nincl)
   return m;
 }
 
-void
+void fsysincid(Mntdir* m) {
-fsysincid(Mntdir *m)
-{
   qlock(&mnt.lk);
   m->ref++;
   qunlock(&mnt.lk);
 }
 
-void
+void fsysdelid(Mntdir* idm) {
-fsysdelid(Mntdir *idm)
-{
   Mntdir *m, *prev;
   int i;
   char buf[64];
 
-	if(idm == nil)
+  if (idm == nil)
     return;
   qlock(&mnt.lk);
-	if(--idm->ref > 0){
+  if (--idm->ref > 0) {
     qunlock(&mnt.lk);
     return;
   }
   prev = nil;
-	for(m=mnt.md; m; m=m->next){
+  for (m = mnt.md; m; m = m->next) {
-		if(m == idm){
+    if (m == idm) {
-			if(prev)
+      if (prev)
         prev->next = m->next;
       else
         mnt.md = m->next;
-			for(i=0; i<m->nincl; i++)
+      for (i = 0; i < m->nincl; i++)
         free(m->incl[i]);
       free(m->incl);
       free(m->dir);
@@ -257,15 +245,11 @@ fsysdelid(Mntdir *idm)
 /*
  * Called only in exec.c:/^run(), from a different FD group
  */
-Mntdir*
+Mntdir* fsysmount(Rune* dir, int ndir, Rune** incl, int nincl) {
-fsysmount(Rune *dir, int ndir, Rune **incl, int nincl)
-{
   return fsysaddid(dir, ndir, incl, nincl);
 }
 
-void
+void fsysclose(void) {
-fsysclose(void)
-{
   closing = 1;
   /*
    * apparently this is not kosher on openbsd.
@@ -275,78 +259,64 @@ fsysclose(void)
    */
 }
 
-Xfid*
+Xfid* respond(Xfid* x, Fcall* t, char* err) {
-respond(Xfid *x, Fcall *t, char *err)
-{
   int n;
 
-	if(err){
+  if (err) {
     t->type = Rerror;
     t->ename = err;
-	}else
+  } else
-		t->type = x->fcall.type+1;
+    t->type = x->fcall.type + 1;
   t->fid = x->fcall.fid;
   t->tag = x->fcall.tag;
-	if(x->buf == nil)
+  if (x->buf == nil)
     x->buf = emalloc(messagesize);
   n = convS2M(t, x->buf, messagesize);
-	if(n <= 0)
+  if (n <= 0)
     error("convert error in convS2M");
-	if(write(sfd, x->buf, n) != n)
+  if (write(sfd, x->buf, n) != n)
     error("write error in respond");
   free(x->buf);
   x->buf = nil;
-	if(DEBUG)
+  if (DEBUG)
     fprint(2, "r: %F\n", t);
   return x;
 }
 
-static
+static Xfid* fsysversion(Xfid* x, Fid* f) {
-Xfid*
-fsysversion(Xfid *x, Fid *f)
-{
   Fcall t;
 
   USED(f);
-	if(x->fcall.msize < 256)
+  if (x->fcall.msize < 256)
     return respond(x, &t, "version: message size too small");
   messagesize = x->fcall.msize;
   t.msize = messagesize;
-	if(strncmp(x->fcall.version, "9P2000", 6) != 0)
+  if (strncmp(x->fcall.version, "9P2000", 6) != 0)
     return respond(x, &t, "unrecognized 9P version");
   t.version = "9P2000";
   return respond(x, &t, nil);
 }
 
-static
+static Xfid* fsysauth(Xfid* x, Fid* f) {
-Xfid*
-fsysauth(Xfid *x, Fid *f)
-{
   Fcall t;
 
   USED(f);
   return respond(x, &t, "acme: authentication not required");
 }
 
-static
+static Xfid* fsysflush(Xfid* x, Fid* f) {
-Xfid*
-fsysflush(Xfid *x, Fid *f)
-{
   USED(f);
   sendp(x->c, (void*)xfidflush);
   return nil;
 }
 
-static
+static Xfid* fsysattach(Xfid* x, Fid* f) {
-Xfid*
-fsysattach(Xfid *x, Fid *f)
-{
   Fcall t;
   int id;
-	Mntdir *m;
+  Mntdir* m;
   char buf[128];
 
-	if(strcmp(x->fcall.uname, user) != 0)
+  if (strcmp(x->fcall.uname, user) != 0)
     return respond(x, &t, Eperm);
   f->busy = TRUE;
   f->open = FALSE;
@@ -360,13 +330,13 @@ fsysattach(Xfid *x, Fid *f)
   f->mntdir = nil;
   id = atoi(x->fcall.aname);
   qlock(&mnt.lk);
-	for(m=mnt.md; m; m=m->next)
+  for (m = mnt.md; m; m = m->next)
-		if(m->id == id){
+    if (m->id == id) {
       f->mntdir = m;
       m->ref++;
       break;
     }
-	if(m == nil && x->fcall.aname[0]){
+  if (m == nil && x->fcall.aname[0]) {
     snprint(buf, sizeof buf, "unknown id '%s' in attach", x->fcall.aname);
     sendp(cerr, estrdup(buf));
   }
@@ -374,38 +344,35 @@ fsysattach(Xfid *x, Fid *f)
   return respond(x, &t, nil);
 }
 
-static
+static Xfid* fsyswalk(Xfid* x, Fid* f) {
-Xfid*
-fsyswalk(Xfid *x, Fid *f)
-{
   Fcall t;
   int c, i, j, id;
   Qid q;
   uchar type;
   ulong path;
-	Fid *nf;
+  Fid* nf;
   Dirtab *d, *dir;
-	Window *w;
+  Window* w;
-	char *err;
+  char* err;
 
   nf = nil;
   w = nil;
-	if(f->open)
+  if (f->open)
     return respond(x, &t, "walk of open file");
-	if(x->fcall.fid != x->fcall.newfid){
+  if (x->fcall.fid != x->fcall.newfid) {
     nf = newfid(x->fcall.newfid);
-		if(nf->busy)
+    if (nf->busy)
       return respond(x, &t, "newfid already in use");
     nf->busy = TRUE;
     nf->open = FALSE;
     nf->mntdir = f->mntdir;
-		if(f->mntdir)
+    if (f->mntdir)
       f->mntdir->ref++;
     nf->dir = f->dir;
     nf->qid = f->qid;
     nf->w = f->w;
     nf->nrpart = 0; /* not open, so must be zero */
-		if(nf->w)
+    if (nf->w)
       incref(&nf->w->ref);
     f = nf; /* walk f */
   }
@@ -416,23 +383,23 @@ fsyswalk(Xfid *x, Fid *f)
   id = WIN(f->qid);
   q = f->qid;
 
-	if(x->fcall.nwname > 0){
+  if (x->fcall.nwname > 0) {
-		for(i=0; i<x->fcall.nwname; i++){
+    for (i = 0; i < x->fcall.nwname; i++) {
-			if((q.type & QTDIR) == 0){
+      if ((q.type & QTDIR) == 0) {
         err = Enotdir;
         break;
       }
 
-			if(strcmp(x->fcall.wname[i], "..") == 0){
+      if (strcmp(x->fcall.wname[i], "..") == 0) {
         type = QTDIR;
         path = Qdir;
         id = 0;
-				if(w){
+        if (w) {
           winclose(w);
           w = nil;
         }
       Accept:
-				if(i == MAXWELEM){
+        if (i == MAXWELEM) {
           err = "name too long";
           break;
         }
@@ -444,16 +411,16 @@ fsyswalk(Xfid *x, Fid *f)
       }
 
       /* is it a numeric name? */
-			for(j=0; (c=x->fcall.wname[i][j]); j++)
+      for (j = 0; (c = x->fcall.wname[i][j]); j++)
-				if(c<'0' || '9'<c)
+        if (c < '0' || '9' < c)
           goto Regular;
       /* yes: it's a directory */
-			if(w)	/* name has form 27/23; get out before losing w */
+      if (w) /* name has form 27/23; get out before losing w */
         break;
       id = atoi(x->fcall.wname[i]);
       qlock(&row.lk);
       w = lookid(id, FALSE);
-			if(w == nil){
+      if (w == nil) {
         qunlock(&row.lk);
         break;
       }
@@ -465,8 +432,8 @@ fsyswalk(Xfid *x, Fid *f)
       goto Accept;
 
     Regular:
-			if(strcmp(x->fcall.wname[i], "new") == 0){
+      if (strcmp(x->fcall.wname[i], "new") == 0) {
-				if(w)
+        if (w)
           error("w set in walk to new");
         sendp(cnewwindow, nil); /* signal newwindowthread */
         w = recvp(cnewwindow);  /* receive new window */
@@ -478,13 +445,13 @@ fsyswalk(Xfid *x, Fid *f)
         goto Accept;
       }
 
-			if(id == 0)
+      if (id == 0)
         d = dirtab;
       else
         d = dirtabw;
       d++; /* skip '.' */
-			for(; d->name; d++)
+      for (; d->name; d++)
-				if(strcmp(x->fcall.wname[i], d->name) == 0){
+        if (strcmp(x->fcall.wname[i], d->name) == 0) {
           path = d->qid;
           type = d->type;
           dir = d;
@@ -494,44 +461,41 @@ fsyswalk(Xfid *x, Fid *f)
       break; /* file not found */
     }
 
-		if(i==0 && err == nil)
+    if (i == 0 && err == nil)
       err = Eexist;
   }
 
-	if(err!=nil || t.nwqid<x->fcall.nwname){
+  if (err != nil || t.nwqid < x->fcall.nwname) {
-		if(nf){
+    if (nf) {
       nf->busy = FALSE;
       fsysdelid(nf->mntdir);
     }
-	}else if(t.nwqid  == x->fcall.nwname){
+  } else if (t.nwqid == x->fcall.nwname) {
-		if(w){
+    if (w) {
       f->w = w;
       w = nil; /* don't drop the reference */
     }
-		if(dir)
+    if (dir)
       f->dir = dir;
     f->qid = q;
   }
 
-	if(w != nil)
+  if (w != nil)
     winclose(w);
 
   return respond(x, &t, err);
 }
 
-static
+static Xfid* fsysopen(Xfid* x, Fid* f) {
-Xfid*
-fsysopen(Xfid *x, Fid *f)
-{
   Fcall t;
   int m;
 
   /* can't truncate anything, so just disregard */
-	x->fcall.mode &= ~(OTRUNC|OCEXEC);
+  x->fcall.mode &= ~(OTRUNC | OCEXEC);
   /* can't execute or remove anything */
-	if(x->fcall.mode==OEXEC || (x->fcall.mode&ORCLOSE))
+  if (x->fcall.mode == OEXEC || (x->fcall.mode & ORCLOSE))
     goto Deny;
-	switch(x->fcall.mode){
+  switch (x->fcall.mode) {
     default:
       goto Deny;
     case OREAD:
@@ -544,79 +508,68 @@ fsysopen(Xfid *x, Fid *f)
       m = 0600;
       break;
   }
-	if(((f->dir->perm&~(DMDIR|DMAPPEND))&m) != m)
+  if (((f->dir->perm & ~(DMDIR | DMAPPEND)) & m) != m)
     goto Deny;
 
   sendp(x->c, (void*)xfidopen);
   return nil;
 
-    Deny:
+Deny:
   return respond(x, &t, Eperm);
 }
 
-static
+static Xfid* fsyscreate(Xfid* x, Fid* f) {
-Xfid*
-fsyscreate(Xfid *x, Fid *f)
-{
   Fcall t;
 
   USED(f);
   return respond(x, &t, Eperm);
 }
 
-static
+static int idcmp(const void* a, const void* b) { return *(int*)a - *(int*)b; }
-int
-idcmp(const void *a, const void *b)
-{
-	return *(int*)a - *(int*)b;
-}
 
-static
+static Xfid* fsysread(Xfid* x, Fid* f) {
-Xfid*
-fsysread(Xfid *x, Fid *f)
-{
   Fcall t;
-	uchar *b;
+  uchar* b;
   int i, id, n, o, e, j, k, *ids, nids;
   Dirtab *d, dt;
-	Column *c;
+  Column* c;
   uint clock, len;
   char buf[16];
 
-	if(f->qid.type & QTDIR){
+  if (f->qid.type & QTDIR) {
-		if(FILE(f->qid) == Qacme){	/* empty dir */
+    if (FILE(f->qid) == Qacme) { /* empty dir */
       t.data = nil;
       t.count = 0;
       respond(x, &t, nil);
       return x;
     }
     o = x->fcall.offset;
-		e = x->fcall.offset+x->fcall.count;
+    e = x->fcall.offset + x->fcall.count;
     clock = getclock();
     b = emalloc(messagesize);
     id = WIN(f->qid);
     n = 0;
-		if(id > 0)
+    if (id > 0)
       d = dirtabw;
     else
       d = dirtab;
     d++; /* first entry is '.' */
-		for(i=0; d->name!=nil && i<e; i+=len){
+    for (i = 0; d->name != nil && i < e; i += len) {
-			len = dostat(WIN(x->f->qid), d, b+n, x->fcall.count-n, clock);
+      len = dostat(WIN(x->f->qid), d, b + n, x->fcall.count - n, clock);
-			if(len <= BIT16SZ)
+      if (len <= BIT16SZ)
         break;
-			if(i >= o)
+      if (i >= o)
         n += len;
       d++;
     }
-		if(id == 0){
+    if (id == 0) {
       qlock(&row.lk);
       nids = 0;
       ids = nil;
-			for(j=0; j<row.ncol; j++){
+      for (j = 0; j < row.ncol; j++) {
         c = row.col[j];
-				for(k=0; k<c->nw; k++){
+        for (k = 0; k < c->nw; k++) {
-					ids = realloc(ids, (nids+1)*sizeof(int));
+          ids = realloc(ids, (nids + 1) * sizeof(int));
           ids[nids++] = c->w[k]->id;
         }
       }
@@ -624,16 +577,16 @@ fsysread(Xfid *x, Fid *f)
       qsort(ids, nids, sizeof ids[0], idcmp);
       j = 0;
       dt.name = buf;
-			for(; j<nids && i<e; i+=len){
+      for (; j < nids && i < e; i += len) {
         k = ids[j];
         sprint(dt.name, "%d", k);
         dt.qid = QID(k, Qdir);
         dt.type = QTDIR;
-				dt.perm = DMDIR|0700;
+        dt.perm = DMDIR | 0700;
-				len = dostat(k, &dt, b+n, x->fcall.count-n, clock);
+        len = dostat(k, &dt, b + n, x->fcall.count - n, clock);
-				if(len == 0)
+        if (len == 0)
           break;
-				if(i >= o)
+        if (i >= o)
           n += len;
         j++;
       }
@@ -649,70 +602,54 @@ fsysread(Xfid *x, Fid *f)
   return nil;
 }
 
-static
+static Xfid* fsyswrite(Xfid* x, Fid* f) {
-Xfid*
-fsyswrite(Xfid *x, Fid *f)
-{
   USED(f);
   sendp(x->c, (void*)xfidwrite);
   return nil;
 }
 
-static
+static Xfid* fsysclunk(Xfid* x, Fid* f) {
-Xfid*
-fsysclunk(Xfid *x, Fid *f)
-{
   fsysdelid(f->mntdir);
   sendp(x->c, (void*)xfidclose);
   return nil;
 }
 
-static
+static Xfid* fsysremove(Xfid* x, Fid* f) {
-Xfid*
-fsysremove(Xfid *x, Fid *f)
-{
   Fcall t;
 
   USED(f);
   return respond(x, &t, Eperm);
 }
 
-static
+static Xfid* fsysstat(Xfid* x, Fid* f) {
-Xfid*
-fsysstat(Xfid *x, Fid *f)
-{
   Fcall t;
 
-	t.stat = emalloc(messagesize-IOHDRSZ);
+  t.stat = emalloc(messagesize - IOHDRSZ);
-	t.nstat = dostat(WIN(x->f->qid), f->dir, t.stat, messagesize-IOHDRSZ, getclock());
+  t.nstat =
+    dostat(WIN(x->f->qid), f->dir, t.stat, messagesize - IOHDRSZ, getclock());
   x = respond(x, &t, nil);
   free(t.stat);
   return x;
 }
 
-static
+static Xfid* fsyswstat(Xfid* x, Fid* f) {
-Xfid*
-fsyswstat(Xfid *x, Fid *f)
-{
   Fcall t;
 
   USED(f);
   return respond(x, &t, Eperm);
 }
 
-Fid*
+Fid* newfid(int fid) {
-newfid(int fid)
-{
   Fid *f, *ff, **fh;
 
   ff = nil;
-	fh = &fids[fid&(Nhash-1)];
+  fh = &fids[fid & (Nhash - 1)];
-	for(f=*fh; f; f=f->next)
+  for (f = *fh; f; f = f->next)
-		if(f->fid == fid)
+    if (f->fid == fid)
       return f;
-		else if(ff==nil && f->busy==FALSE)
+    else if (ff == nil && f->busy == FALSE)
       ff = f;
-	if(ff){
+  if (ff) {
     ff->fid = fid;
     return ff;
   }
@@ -723,15 +660,9 @@ newfid(int fid)
   return f;
 }
 
-uint
+uint getclock(void) { return time(0); }
-getclock(void)
-{
-	return time(0);
-}
 
-int
+int dostat(int id, Dirtab* dir, uchar* buf, int nbuf, uint clock) {
-dostat(int id, Dirtab *dir, uchar *buf, int nbuf, uint clock)
-{
   Dir d;
 
   d.qid.path = QID(id, dir->qid);

logf.c

@@ -14,40 +14,37 @@
 
 // State for global log file.
 typedef struct Log Log;
-struct Log
+struct Log {
-{
   QLock lk;
   Rendez r;
 
   vlong start; // msg[0] corresponds to 'start' in the global sequence of events
 
   // queued events (nev=entries in ev, mev=capacity of p)
-	char **ev;
+  char** ev;
   int nev;
   int mev;
 
   // open acme/put files that need to read events
-	Fid **f;
+  Fid** f;
   int nf;
   int mf;
 
   // active (blocked) reads waiting for events
-	Xfid **read;
+  Xfid** read;
   int nread;
   int mread;
 };
 
 static Log eventlog;
 
-void
+void xfidlogopen(Xfid* x) {
-xfidlogopen(Xfid *x)
-{
   qlock(&eventlog.lk);
-	if(eventlog.nf >= eventlog.mf) {	
+  if (eventlog.nf >= eventlog.mf) {
-		eventlog.mf = eventlog.mf*2;
+    eventlog.mf = eventlog.mf * 2;
-		if(eventlog.mf == 0)
+    if (eventlog.mf == 0)
       eventlog.mf = 8;
-		eventlog.f = erealloc(eventlog.f, eventlog.mf*sizeof eventlog.f[0]);
+    eventlog.f = erealloc(eventlog.f, eventlog.mf * sizeof eventlog.f[0]);
   }
   eventlog.f[eventlog.nf++] = x->f;
   x->f->logoff = eventlog.start + eventlog.nev;
@@ -55,14 +52,12 @@ xfidlogopen(Xfid *x)
   qunlock(&eventlog.lk);
 }
 
-void
+void xfidlogclose(Xfid* x) {
-xfidlogclose(Xfid *x)
-{
   int i;
 
   qlock(&eventlog.lk);
-	for(i=0; i<eventlog.nf; i++) {
+  for (i = 0; i < eventlog.nf; i++) {
-		if(eventlog.f[i] == x->f) {
+    if (eventlog.f[i] == x->f) {
       eventlog.f[i] = eventlog.f[--eventlog.nf];
       break;
     }
@@ -70,36 +65,35 @@ xfidlogclose(Xfid *x)
   qunlock(&eventlog.lk);
 }
 
-void
+void xfidlogread(Xfid* x) {
-xfidlogread(Xfid *x)
+  char* p;
-{
-	char *p;
   int i;
   Fcall fc;
 
   qlock(&eventlog.lk);
-	if(eventlog.nread >= eventlog.mread) {	
+  if (eventlog.nread >= eventlog.mread) {
-		eventlog.mread = eventlog.mread*2;
+    eventlog.mread = eventlog.mread * 2;
-		if(eventlog.mread == 0)
+    if (eventlog.mread == 0)
       eventlog.mread = 8;
-		eventlog.read = erealloc(eventlog.read, eventlog.mread*sizeof eventlog.read[0]);
+    eventlog.read =
+      erealloc(eventlog.read, eventlog.mread * sizeof eventlog.read[0]);
   }
   eventlog.read[eventlog.nread++] = x;
 
-	if(eventlog.r.l == nil)
+  if (eventlog.r.l == nil)
     eventlog.r.l = &eventlog.lk;
   x->flushed = FALSE;
-	while(x->f->logoff >= eventlog.start+eventlog.nev && !x->flushed)
+  while (x->f->logoff >= eventlog.start + eventlog.nev && !x->flushed)
     rsleep(&eventlog.r);
 
-	for(i=0; i<eventlog.nread; i++) {
+  for (i = 0; i < eventlog.nread; i++) {
-		if(eventlog.read[i] == x) {
+    if (eventlog.read[i] == x) {
       eventlog.read[i] = eventlog.read[--eventlog.nread];
       break;
     }
   }
 
-	if(x->flushed) {
+  if (x->flushed) {
     qunlock(&eventlog.lk);
     return;
   }
@@ -115,16 +109,14 @@ xfidlogread(Xfid *x)
   free(p);
 }
 
-void
+void xfidlogflush(Xfid* x) {
-xfidlogflush(Xfid *x)
-{
   int i;
-	Xfid *rx;
+  Xfid* rx;
 
   qlock(&eventlog.lk);
-	for(i=0; i<eventlog.nread; i++) {
+  for (i = 0; i < eventlog.nread; i++) {
     rx = eventlog.read[i];
-		if(rx->fcall.tag == x->fcall.oldtag) {
+    if (rx->fcall.tag == x->fcall.oldtag) {
       rx->flushed = TRUE;
       rwakeupall(&eventlog.r);
     }
@@ -153,46 +145,47 @@ xfidlogflush(Xfid *x)
  * op == "del" for deleted window
  *	- called from winclose
  */
-void
+void xfidlog(Window* w, char* op) {
-xfidlog(Window *w, char *op)
-{
   int i, n;
   vlong min;
-	File *f;
+  File* f;
-	char *name;
+  char* name;
 
   qlock(&eventlog.lk);
-	if(eventlog.nev >= eventlog.mev) {
+  if (eventlog.nev >= eventlog.mev) {
     // Remove and free any entries that all readers have read.
     min = eventlog.start + eventlog.nev;
-		for(i=0; i<eventlog.nf; i++) {
+    for (i = 0; i < eventlog.nf; i++) {
-			if(min > eventlog.f[i]->logoff)
+      if (min > eventlog.f[i]->logoff)
         min = eventlog.f[i]->logoff;
     }
-		if(min > eventlog.start) {
+    if (min > eventlog.start) {
       n = min - eventlog.start;
-			for(i=0; i<n; i++)
+      for (i = 0; i < n; i++)
         free(eventlog.ev[i]);
       eventlog.nev -= n;
       eventlog.start += n;
-			memmove(eventlog.ev, eventlog.ev+n, eventlog.nev*sizeof eventlog.ev[0]);
+      memmove(
+        eventlog.ev,
+        eventlog.ev + n,
+        eventlog.nev * sizeof eventlog.ev[0]);
     }
 
     // Otherwise grow.
-		if(eventlog.nev >= eventlog.mev) {
+    if (eventlog.nev >= eventlog.mev) {
-			eventlog.mev = eventlog.mev*2;
+      eventlog.mev = eventlog.mev * 2;
-			if(eventlog.mev == 0)
+      if (eventlog.mev == 0)
         eventlog.mev = 8;
-			eventlog.ev = erealloc(eventlog.ev, eventlog.mev*sizeof eventlog.ev[0]);
+      eventlog.ev = erealloc(eventlog.ev, eventlog.mev * sizeof eventlog.ev[0]);
     }
   }
   f = w->body.file;
   name = runetobyte(f->name, f->nname);
-	if(name == nil)
+  if (name == nil)
     name = estrdup("");
   eventlog.ev[eventlog.nev++] = smprint("%d %s %s\n", w->id, op, name);
   free(name);
-	if(eventlog.r.l == nil)
+  if (eventlog.r.l == nil)
     eventlog.r.l = &eventlog.lk;
   rwakeupall(&eventlog.r);
   qunlock(&eventlog.lk);

mail/html.c

@@ -7,23 +7,21 @@
 #include <9pclient.h>
 #include "dat.h"
 
-char*
+char* formathtml(char* body, int* np) {
-formathtml(char *body, int *np)
-{
   int i, j, p[2], q[2];
-	Exec *e;
+  Exec* e;
   char buf[1024];
-	Channel *sync;
+  Channel* sync;
 
   e = emalloc(sizeof(struct Exec));
-	if(pipe(p) < 0 || pipe(q) < 0)
+  if (pipe(p) < 0 || pipe(q) < 0)
     error("can't create pipe: %r");
 
   e->p[0] = p[0];
   e->p[1] = p[1];
   e->q[0] = q[0];
   e->q[1] = q[1];
-	e->argv = emalloc(3*sizeof(char*));
+  e->argv = emalloc(3 * sizeof(char*));
   e->argv[0] = estrdup("htmlfmt");
   e->argv[1] = estrdup("-cutf-8");
   e->argv[2] = nil;
@@ -35,7 +33,7 @@ formathtml(char *body, int *np)
   close(p[0]);
   close(q[1]);
 
-	if((i=write(p[1], body, *np)) != *np){
+  if ((i = write(p[1], body, *np)) != *np) {
     fprint(2, "Mail: warning: htmlfmt failed: wrote %d of %d: %r\n", i, *np);
     close(p[1]);
     close(q[0]);
@@ -46,14 +44,14 @@ formathtml(char *body, int *np)
   free(body);
   body = nil;
   i = 0;
-	for(;;){
+  for (;;) {
     j = read(q[0], buf, sizeof buf);
-		if(j <= 0)
+    if (j <= 0)
       break;
-		body = realloc(body, i+j+1);
+    body = realloc(body, i + j + 1);
-		if(body == nil)
+    if (body == nil)
       error("realloc failed: %r");
-		memmove(body+i, buf, j);
+    memmove(body + i, buf, j);
     i += j;
     body[i] = '\0';
   }
@@ -63,13 +61,11 @@ formathtml(char *body, int *np)
   return body;
 }
 
-char*
+char* readbody(char* type, char* dir, int* np) {
-readbody(char *type, char *dir, int *np)
+  char* body;
-{
-	char *body;
 
   body = readfile(dir, "body", np);
-	if(body != nil && strcmp(type, "text/html") == 0)
+  if (body != nil && strcmp(type, "text/html") == 0)
     return formathtml(body, np);
   return body;
 }

mail/mail.c

@@ -7,25 +7,25 @@
 #include <ctype.h>
 #include "dat.h"
 
-char	*maildir = "Mail/";			/* mountpoint of mail file system */
+char* maildir = "Mail/"; /* mountpoint of mail file system */
-char *mboxname = "mbox";			/* mailboxdir/mboxname is mail spool file */
+char* mboxname = "mbox"; /* mailboxdir/mboxname is mail spool file */
-char	*mailboxdir = nil;				/* nil == /mail/box/$user */
+char* mailboxdir = nil;  /* nil == /mail/box/$user */
-char *fsname;						/* filesystem for mailboxdir/mboxname is at maildir/fsname */
+char* fsname; /* filesystem for mailboxdir/mboxname is at maildir/fsname */
-char	*user;
+char* user;
-char	*outgoing;
+char* outgoing;
-char *srvname;
+char* srvname;
 
-Window	*wbox;
+Window* wbox;
 Message mbox;
 Message replies;
-char		*home;
+char* home;
-CFid		*plumbsendfd;
+CFid* plumbsendfd;
-CFid		*plumbseemailfd;
+CFid* plumbseemailfd;
-CFid		*plumbshowmailfd;
+CFid* plumbshowmailfd;
-CFid		*plumbsendmailfd;
+CFid* plumbsendmailfd;
-Channel	*cplumb;
+Channel* cplumb;
-Channel	*cplumbshow;
+Channel* cplumbshow;
-Channel	*cplumbsend;
+Channel* cplumbsend;
 int wctlfd;
 void mainctl(void*);
 void plumbproc(void*);
@@ -37,44 +37,39 @@ void		plumbsendthread(void*);
 
 int shortmenu;
 
-CFsys *mailfs;
+CFsys* mailfs;
-CFsys *acmefs;
+CFsys* acmefs;
 
-void
+void usage(void) {
-usage(void)
+  fprint(
-{
+    2,
-	fprint(2, "usage: Mail [-sS] [-n srvname] [-o outgoing] [mailboxname [directoryname]]\n");
+    "usage: Mail [-sS] [-n srvname] [-o outgoing] [mailboxname "
+    "[directoryname]]\n");
   threadexitsall("usage");
 }
 
-void
+void removeupasfs(void) {
-removeupasfs(void)
-{
   char buf[256];
 
-	if(strcmp(mboxname, "mbox") == 0)
+  if (strcmp(mboxname, "mbox") == 0)
     return;
   snprint(buf, sizeof buf, "close %s", mboxname);
   fswrite(mbox.ctlfd, buf, strlen(buf));
 }
 
-int
+int ismaildir(char* s) {
-ismaildir(char *s)
+  Dir* d;
-{
-	Dir *d;
   int ret;
 
   d = fsdirstat(mailfs, s);
-	if(d == nil)
+  if (d == nil)
     return 0;
   ret = d->qid.type & QTDIR;
   free(d);
   return ret;
 }
 
-void
+void threadmain(int argc, char* argv[]) {
-threadmain(int argc, char *argv[])
-{
   char *s, *name;
   char err[ERRMAX], *cmd;
   int i, newdir;
@@ -83,17 +78,18 @@ threadmain(int argc, char *argv[])
   doquote = needsrcquote;
   quotefmtinstall();
 
-	/* open these early so we won't miss notification of new mail messages while we read mbox */
+  /* open these early so we won't miss notification of new mail messages while
-	if((plumbsendfd = plumbopenfid("send", OWRITE|OCEXEC)) == nil)
+   * we read mbox */
+  if ((plumbsendfd = plumbopenfid("send", OWRITE | OCEXEC)) == nil)
     fprint(2, "warning: open plumb/send: %r\n");
-	if((plumbseemailfd = plumbopenfid("seemail", OREAD|OCEXEC)) == nil)
+  if ((plumbseemailfd = plumbopenfid("seemail", OREAD | OCEXEC)) == nil)
     fprint(2, "warning: open plumb/seemail: %r\n");
-	if((plumbshowmailfd = plumbopenfid("showmail", OREAD|OCEXEC)) == nil)
+  if ((plumbshowmailfd = plumbopenfid("showmail", OREAD | OCEXEC)) == nil)
     fprint(2, "warning: open plumb/showmail: %r\n");
 
   shortmenu = 0;
   srvname = "mail";
-	ARGBEGIN{
+  ARGBEGIN {
     case 's':
       shortmenu = 1;
       break;
@@ -111,41 +107,42 @@ threadmain(int argc, char *argv[])
       break;
     default:
       usage();
-	}ARGEND
+  }
+  ARGEND
 
-	acmefs = nsmount("acme",nil);
+  acmefs = nsmount("acme", nil);
-	if(acmefs == nil)
+  if (acmefs == nil)
     error("cannot mount acme: %r");
   mailfs = nsmount(srvname, nil);
-	if(mailfs == nil)
+  if (mailfs == nil)
     error("cannot mount %s: %r", srvname);
 
   name = "mbox";
 
   newdir = 1;
-	if(argc > 0){
+  if (argc > 0) {
     i = strlen(argv[0]);
-		if(argc>2 || i==0)
+    if (argc > 2 || i == 0)
       usage();
     /* see if the name is that of an existing /mail/fs directory */
-		if(argc==1 && argv[0][0] != '/' && ismaildir(argv[0])){
+    if (argc == 1 && argv[0][0] != '/' && ismaildir(argv[0])) {
       name = argv[0];
       mboxname = estrdup(name);
       newdir = 0;
-		}else{
+    } else {
-			if(argv[0][i-1] == '/')
+      if (argv[0][i - 1] == '/')
-				argv[0][i-1] = '\0';
+        argv[0][i - 1] = '\0';
       s = strrchr(argv[0], '/');
-			if(s == nil)
+      if (s == nil)
         mboxname = estrdup(argv[0]);
-			else{
+      else {
         *s++ = '\0';
-				if(*s == '\0')
+        if (*s == '\0')
           usage();
         mailboxdir = argv[0];
         mboxname = estrdup(s);
       }
-			if(argc > 1)
+      if (argc > 1)
         name = argv[1];
       else
         name = mboxname;
@@ -153,64 +150,65 @@ threadmain(int argc, char *argv[])
   }
 
   user = getenv("user");
-	if(user == nil)
+  if (user == nil)
     user = "none";
   home = getenv("home");
-	if(home == nil)
+  if (home == nil)
     home = getenv("HOME");
-	if(home == nil)
+  if (home == nil)
     error("can't find $home");
-	if(mailboxdir == nil)
+  if (mailboxdir == nil)
     mailboxdir = estrstrdup(home, "/mail");
-	if(outgoing == nil)
+  if (outgoing == nil)
     outgoing = estrstrdup(mailboxdir, "/outgoing");
 
   mbox.ctlfd = fsopen(mailfs, estrstrdup(mboxname, "/ctl"), OWRITE);
-	if(mbox.ctlfd == nil)
+  if (mbox.ctlfd == nil)
     error("can't open %s: %r", estrstrdup(mboxname, "/ctl"));
 
   fsname = estrdup(name);
-	if(newdir && argc > 0){
+  if (newdir && argc > 0) {
-		s = emalloc(5+strlen(mailboxdir)+strlen(mboxname)+strlen(name)+10+1);
+    s = emalloc(
-		for(i=0; i<10; i++){
+      5 + strlen(mailboxdir) + strlen(mboxname) + strlen(name) + 10 + 1);
+    for (i = 0; i < 10; i++) {
       sprint(s, "open %s/%s %s", mailboxdir, mboxname, fsname);
-			if(fswrite(mbox.ctlfd, s, strlen(s)) >= 0)
+      if (fswrite(mbox.ctlfd, s, strlen(s)) >= 0)
         break;
       err[0] = '\0';
       errstr(err, sizeof err);
-			if(strstr(err, "mbox name in use") == nil)
+      if (strstr(err, "mbox name in use") == nil)
         error("can't create directory %s for mail: %s", name, err);
       free(fsname);
-			fsname = emalloc(strlen(name)+10);
+      fsname = emalloc(strlen(name) + 10);
       sprint(fsname, "%s-%d", name, i);
     }
-		if(i == 10)
+    if (i == 10)
       error("can't open %s/%s: %r", mailboxdir, mboxname);
     free(s);
   }
 
   s = estrstrdup(fsname, "/");
   mbox.name = estrstrdup(maildir, s);
-	mbox.level= 0;
+  mbox.level = 0;
   readmbox(&mbox, maildir, s);
   home = getenv("home");
-	if(home == nil)
+  if (home == nil)
     home = "/";
 
   wbox = newwindow();
   winname(wbox, mbox.name);
-	wintagwrite(wbox, "Put Mail Delmesg ", 3+1+4+1+7+1);
+  wintagwrite(wbox, "Put Mail Delmesg ", 3 + 1 + 4 + 1 + 7 + 1);
   threadcreate(mainctl, wbox, STACK);
 
   fmtstrinit(&fmt);
   fmtprint(&fmt, "Mail");
-	if(shortmenu)
+  if (shortmenu)
-		fmtprint(&fmt, " -%c", "sS"[shortmenu-1]);
+    fmtprint(&fmt, " -%c", "sS"[shortmenu - 1]);
-	if(outgoing)
+  if (outgoing)
     fmtprint(&fmt, " -o %s", outgoing);
   fmtprint(&fmt, " %s", name);
   cmd = fmtstrflush(&fmt);
-	if(cmd == nil)
+  if (cmd == nil)
     sysfatal("out of memory");
   winsetdump(wbox, "/acme/mail", cmd);
   mbox.w = wbox;
@@ -218,16 +216,16 @@ threadmain(int argc, char *argv[])
   mesgmenu(wbox, &mbox);
   winclean(wbox);
 
-/*	wctlfd = open("/dev/wctl", OWRITE|OCEXEC);	/* for acme window */
+  /*	wctlfd = open("/dev/wctl", OWRITE|OCEXEC);	/* for acme window */
   wctlfd = -1;
   cplumb = chancreate(sizeof(Plumbmsg*), 0);
   cplumbshow = chancreate(sizeof(Plumbmsg*), 0);
-	if(strcmp(name, "mbox") == 0){
+  if (strcmp(name, "mbox") == 0) {
     /*
      * Avoid creating multiple windows to send mail by only accepting
      * sendmail plumb messages if we're reading the main mailbox.
      */
-		plumbsendmailfd = plumbopenfid("sendmail", OREAD|OCEXEC);
+    plumbsendmailfd = plumbopenfid("sendmail", OREAD | OCEXEC);
     cplumbsend = chancreate(sizeof(Plumbmsg*), 0);
     proccreate(plumbsendproc, nil, STACK);
     threadcreate(plumbsendthread, nil, STACK);
@@ -241,120 +239,106 @@ threadmain(int argc, char *argv[])
   plumbthread();
 }
 
-void
+void plumbproc(void* v) {
-plumbproc(void* v)
+  Plumbmsg* m;
-{
-	Plumbmsg *m;
 
   threadsetname("plumbproc");
-	for(;;){
+  for (;;) {
     m = plumbrecvfid(plumbseemailfd);
     sendp(cplumb, m);
-		if(m == nil)
+    if (m == nil)
       threadexits(nil);
   }
 }
 
-void
+void plumbshowproc(void* v) {
-plumbshowproc(void* v)
+  Plumbmsg* m;
-{
-	Plumbmsg *m;
 
   threadsetname("plumbshowproc");
-	for(;;){
+  for (;;) {
     m = plumbrecvfid(plumbshowmailfd);
     sendp(cplumbshow, m);
-		if(m == nil)
+    if (m == nil)
       threadexits(nil);
   }
 }
 
-void
+void plumbsendproc(void* v) {
-plumbsendproc(void* v)
+  Plumbmsg* m;
-{
-	Plumbmsg *m;
 
   threadsetname("plumbsendproc");
-	for(;;){
+  for (;;) {
     m = plumbrecvfid(plumbsendmailfd);
     sendp(cplumbsend, m);
-		if(m == nil)
+    if (m == nil)
       threadexits(nil);
   }
 }
 
-void
+void newmesg(char* name, char* digest) {
-newmesg(char *name, char *digest)
+  Dir* d;
-{
-	Dir *d;
 
-	if(strncmp(name, mbox.name, strlen(mbox.name)) != 0)
+  if (strncmp(name, mbox.name, strlen(mbox.name)) != 0)
     return; /* message is about another mailbox */
-	if(mesglookupfile(&mbox, name, digest) != nil)
+  if (mesglookupfile(&mbox, name, digest) != nil)
     return;
-	if(strncmp(name, "Mail/", 5) == 0)
+  if (strncmp(name, "Mail/", 5) == 0)
     name += 5;
   d = fsdirstat(mailfs, name);
-	if(d == nil)
+  if (d == nil)
     return;
-	if(mesgadd(&mbox, mbox.name, d, digest))
+  if (mesgadd(&mbox, mbox.name, d, digest))
     mesgmenunew(wbox, &mbox);
   free(d);
 }
 
-void
+void showmesg(char* name, char* digest) {
-showmesg(char *name, char *digest)
+  char* n;
-{
+  char* mb;
-	char *n;
-	char *mb;
 
   mb = mbox.name;
-	if(strncmp(name, mb, strlen(mb)) != 0)
+  if (strncmp(name, mb, strlen(mb)) != 0)
     return; /* message is about another mailbox */
-	n = estrdup(name+strlen(mb));
+  n = estrdup(name + strlen(mb));
-	if(n[strlen(n)-1] != '/')
+  if (n[strlen(n) - 1] != '/')
     n = egrow(n, "/", nil);
-	mesgopen(&mbox, mbox.name, name+strlen(mb), nil, 1, digest);
+  mesgopen(&mbox, mbox.name, name + strlen(mb), nil, 1, digest);
   free(n);
 }
 
-void
+void delmesg(char* name, char* digest, int dodel, char* save) {
-delmesg(char *name, char *digest, int dodel, char *save)
+  Message* m;
-{
-	Message *m;
 
   m = mesglookupfile(&mbox, name, digest);
-	if(m != nil){
+  if (m != nil) {
-		if(save)
+    if (save)
       mesgcommand(m, estrstrdup("Save ", save));
-		if(dodel)
+    if (dodel)
       mesgmenumarkdel(wbox, &mbox, m, 1);
-		else{
+    else {
       /* notification came from plumber - message is gone */
       mesgmenudel(wbox, &mbox, m);
-			if(!m->opened)
+      if (!m->opened)
         mesgdel(&mbox, m);
     }
   }
 }
 
-void
+void plumbthread(void) {
-plumbthread(void)
+  Plumbmsg* m;
-{
+  Plumbattr* a;
-	Plumbmsg *m;
-	Plumbattr *a;
   char *type, *digest;
 
   threadsetname("plumbthread");
-	while((m = recvp(cplumb)) != nil){
+  while ((m = recvp(cplumb)) != nil) {
     a = m->attr;
     digest = plumblookup(a, "digest");
     type = plumblookup(a, "mailtype");
-		if(type == nil)
+    if (type == nil)
       fprint(2, "Mail: plumb message with no mailtype attribute\n");
-		else if(strcmp(type, "new") == 0)
+    else if (strcmp(type, "new") == 0)
       newmesg(m->data, digest);
-		else if(strcmp(type, "delete") == 0)
+    else if (strcmp(type, "delete") == 0)
       delmesg(m->data, digest, 0, nil);
     else
       fprint(2, "Mail: unknown plumb attribute %s\n", type);
@@ -363,116 +347,111 @@ plumbthread(void)
   threadexits(nil);
 }
 
-void
+void plumbshowthread(void* v) {
-plumbshowthread(void *v)
+  Plumbmsg* m;
-{
-	Plumbmsg *m;
 
   USED(v);
   threadsetname("plumbshowthread");
-	while((m = recvp(cplumbshow)) != nil){
+  while ((m = recvp(cplumbshow)) != nil) {
     showmesg(m->data, plumblookup(m->attr, "digest"));
     plumbfree(m);
   }
   threadexits(nil);
 }
 
-void
+void plumbsendthread(void* v) {
-plumbsendthread(void *v)
+  Plumbmsg* m;
-{
-	Plumbmsg *m;
 
   USED(v);
   threadsetname("plumbsendthread");
-	while((m = recvp(cplumbsend)) != nil){
+  while ((m = recvp(cplumbsend)) != nil) {
     mkreply(nil, "Mail", m->data, m->attr, nil);
     plumbfree(m);
   }
   threadexits(nil);
 }
 
-int
+int mboxcommand(Window* w, char* s) {
-mboxcommand(Window *w, char *s)
-{
   char *args[10], **targs, *save;
-	Window *sbox;
+  Window* sbox;
   Message *m, *next;
   int ok, nargs, i, j;
-	CFid *searchfd;
+  CFid* searchfd;
   char buf[128], *res;
 
   nargs = tokenize(s, args, nelem(args));
-	if(nargs == 0)
+  if (nargs == 0)
     return 0;
-	if(strcmp(args[0], "Mail") == 0){
+  if (strcmp(args[0], "Mail") == 0) {
-		if(nargs == 1)
+    if (nargs == 1)
       mkreply(nil, "Mail", "", nil, nil);
     else
       mkreply(nil, "Mail", args[1], nil, nil);
     return 1;
   }
-	if(strcmp(s, "Del") == 0){
+  if (strcmp(s, "Del") == 0) {
-		if(mbox.dirty){
+    if (mbox.dirty) {
       mbox.dirty = 0;
       fprint(2, "mail: mailbox not written\n");
       return 1;
     }
-		if(w != mbox.w){
+    if (w != mbox.w) {
       windel(w, 1);
       return 1;
     }
     ok = 1;
-		for(m=mbox.head; m!=nil; m=next){
+    for (m = mbox.head; m != nil; m = next) {
       next = m->next;
-			if(m->w){
+      if (m->w) {
-				if(windel(m->w, 0))
+        if (windel(m->w, 0))
           m->w = nil;
         else
           ok = 0;
       }
     }
-		for(m=replies.head; m!=nil; m=next){
+    for (m = replies.head; m != nil; m = next) {
       next = m->next;
-			if(m->w){
+      if (m->w) {
-				if(windel(m->w, 0))
+        if (windel(m->w, 0))
           m->w = nil;
         else
           ok = 0;
       }
     }
-		if(ok){
+    if (ok) {
       windel(w, 1);
       removeupasfs();
       threadexitsall(nil);
     }
     return 1;
   }
-	if(strcmp(s, "Put") == 0){
+  if (strcmp(s, "Put") == 0) {
     rewritembox(wbox, &mbox);
     return 1;
   }
-	if(strcmp(s, "Get") == 0){
+  if (strcmp(s, "Get") == 0) {
     fswrite(mbox.ctlfd, "refresh", 7);
     return 1;
   }
-	if(strcmp(s, "Delmesg") == 0){
+  if (strcmp(s, "Delmesg") == 0) {
     save = nil;
-		if(nargs > 1)
+    if (nargs > 1)
       save = args[1];
     s = winselection(w);
-		if(s == nil)
+    if (s == nil)
       return 1;
     nargs = 1;
-		for(i=0; s[i]; i++)
+    for (i = 0; s[i]; i++)
-			if(s[i] == '\n')
+      if (s[i] == '\n')
         nargs++;
-		targs = emalloc(nargs*sizeof(char*));	/* could be too many for a local array */
+    targs =
+      emalloc(nargs * sizeof(char*)); /* could be too many for a local array */
     nargs = getfields(s, targs, nargs, 1, "\n");
-		for(i=0; i<nargs; i++){
+    for (i = 0; i < nargs; i++) {
-			if(!isdigit(targs[i][0]))
+      if (!isdigit(targs[i][0]))
         continue;
       j = atoi(targs[i]); /* easy way to parse the number! */
-			if(j == 0)
+      if (j == 0)
         continue;
       snprint(buf, sizeof buf, "%s%d", mbox.name, j);
       delmesg(buf, nil, 1, save);
@@ -481,20 +460,20 @@ mboxcommand(Window *w, char *s)
     free(targs);
     return 1;
   }
-	if(strcmp(s, "Search") == 0){
+  if (strcmp(s, "Search") == 0) {
-		if(nargs <= 1)
+    if (nargs <= 1)
       return 1;
     s = estrstrdup(mboxname, "/search");
     searchfd = fsopen(mailfs, s, ORDWR);
-		if(searchfd == nil)
+    if (searchfd == nil)
       return 1;
     save = estrdup(args[1]);
-		for(i=2; i<nargs; i++)
+    for (i = 2; i < nargs; i++)
       save = eappend(save, " ", args[i]);
     fswrite(searchfd, save, strlen(save));
     fsseek(searchfd, 0, 0);
     j = fsread(searchfd, buf, sizeof buf - 1);
- 		if(j == 0){
+    if (j == 0) {
       fprint(2, "[%s] search %s: no results found\n", mboxname, save);
       fsclose(searchfd);
       free(save);
@@ -504,7 +483,7 @@ mboxcommand(Window *w, char *s)
     buf[j] = '\0';
     res = estrdup(buf);
     j = fsread(searchfd, buf, sizeof buf - 1);
-		for(; j != 0; j = fsread(searchfd, buf, sizeof buf - 1), buf[j] = '\0')
+    for (; j != 0; j = fsread(searchfd, buf, sizeof buf - 1), buf[j] = '\0')
       res = eappend(res, "", buf);
     fsclose(searchfd);
 
@@ -517,16 +496,18 @@ mboxcommand(Window *w, char *s)
     /* show results in reverse order */
     m = mbox.tail;
     save = nil;
-		for(s=strrchr(res, ' '); s!=nil || save!=res; s=strrchr(res, ' ')){
+    for (s = strrchr(res, ' '); s != nil || save != res;
-			if(s != nil){
+         s = strrchr(res, ' ')) {
-				save = s+1;
+      if (s != nil) {
+        save = s + 1;
         *s = '\0';
-			}
+      } else
-			else save = res;
+        save = res;
       save = estrstrdup(save, "/");
-			for(; m && strcmp(save, m->name) != 0; m=m->prev);
+      for (; m && strcmp(save, m->name) != 0; m = m->prev)
+        ;
       free(save);
-			if(m == nil)
+      if (m == nil)
         break;
       fsprint(sbox->body, "%s%s\n", m->name, info(m, 0, 0));
       m = m->prev;
@@ -539,10 +520,8 @@ mboxcommand(Window *w, char *s)
   return 0;
 }
 
-void
+void mainctl(void* v) {
-mainctl(void *v)
+  Window* w;
-{
-	Window *w;
   Event *e, *e2, *eq, *ea;
   int na, nopen;
   char *s, *t, *buf;
@@ -551,9 +530,9 @@ mainctl(void *v)
   winincref(w);
   proccreate(wineventproc, w, STACK);
 
-	for(;;){
+  for (;;) {
     e = recvp(w->cevent);
-		switch(e->c1){
+    switch (e->c1) {
       default:
       Unknown:
         print("unknown message %c%c\n", e->c1, e->c2);
@@ -569,32 +548,32 @@ mainctl(void *v)
         break;
 
       case 'M':
-			switch(e->c2){
+        switch (e->c2) {
           case 'x':
           case 'X':
             ea = nil;
             e2 = nil;
-				if(e->flag & 2)
+            if (e->flag & 2)
               e2 = recvp(w->cevent);
-				if(e->flag & 8){
+            if (e->flag & 8) {
               ea = recvp(w->cevent);
               na = ea->nb;
               recvp(w->cevent);
-				}else
+            } else
               na = 0;
             s = e->b;
             /* if it's a known command, do it */
-				if((e->flag&2) && e->nb==0)
+            if ((e->flag & 2) && e->nb == 0)
               s = e2->b;
-				if(na){
+            if (na) {
-					t = emalloc(strlen(s)+1+na+1);
+              t = emalloc(strlen(s) + 1 + na + 1);
               sprint(t, "%s %s", s, ea->b);
               s = t;
             }
             /* if it's a long message, it can't be for us anyway */
-				if(!mboxcommand(w, s))	/* send it back */
+            if (!mboxcommand(w, s)) /* send it back */
               winwriteevent(w, e);
-				if(na)
+            if (na)
               free(s);
             break;
 
@@ -602,29 +581,29 @@ mainctl(void *v)
           case 'L':
             buf = nil;
             eq = e;
-				if(e->flag & 2){
+            if (e->flag & 2) {
               e2 = recvp(w->cevent);
               eq = e2;
             }
             s = eq->b;
-				if(eq->q1>eq->q0 && eq->nb==0){
+            if (eq->q1 > eq->q0 && eq->nb == 0) {
-					buf = emalloc((eq->q1-eq->q0)*UTFmax+1);
+              buf = emalloc((eq->q1 - eq->q0) * UTFmax + 1);
               winread(w, eq->q0, eq->q1, buf);
               s = buf;
             }
             nopen = 0;
-				do{
+            do {
               /* skip 'deleted' string if present' */
-					if(strncmp(s, deleted, strlen(deleted)) == 0)
+              if (strncmp(s, deleted, strlen(deleted)) == 0)
                 s += strlen(deleted);
               /* skip mail box name if present */
-					if(strncmp(s, mbox.name, strlen(mbox.name)) == 0)
+              if (strncmp(s, mbox.name, strlen(mbox.name)) == 0)
                 s += strlen(mbox.name);
               nopen += mesgopen(&mbox, mbox.name, s, nil, 0, nil);
-					while(*s!='\0' && *s++!='\n')
+              while (*s != '\0' && *s++ != '\n')
                 ;
-				}while(*s);
+            } while (*s);
-				if(nopen == 0)	/* send it back */
+            if (nopen == 0) /* send it back */
               winwriteevent(w, e);
             free(buf);
             break;
@@ -641,4 +620,3 @@ mainctl(void *v)
     }
   }
 }
-

mail/reply.c

@@ -9,56 +9,56 @@
 
 static int replyid;
 
-int
+int quote(Message* m, CFid* fid, char* dir, char* quotetext) {
-quote(Message *m, CFid *fid, char *dir, char *quotetext)
-{
   char *body, *type;
   int i, n, nlines;
-	char **lines;
+  char** lines;
 
-	if(quotetext){
+  if (quotetext) {
     body = quotetext;
     n = strlen(body);
     type = nil;
-	}else{
+  } else {
     /* look for first textual component to quote */
     type = readfile(dir, "type", &n);
-		if(type == nil){
+    if (type == nil) {
       print("no type in %s\n", dir);
       return 0;
     }
-		if(strncmp(type, "multipart/", 10)==0 || strncmp(type, "message/", 8)==0){
+    if (
+      strncmp(type, "multipart/", 10) == 0 ||
+      strncmp(type, "message/", 8) == 0) {
       dir = estrstrdup(dir, "1/");
-			if(quote(m, fid, dir, nil)){
+      if (quote(m, fid, dir, nil)) {
         free(type);
         free(dir);
         return 1;
       }
       free(dir);
     }
-		if(strncmp(type, "text", 4) != 0){
+    if (strncmp(type, "text", 4) != 0) {
       free(type);
       return 0;
     }
     body = readbody(m->type, dir, &n);
-		if(body == nil)
+    if (body == nil)
       return 0;
   }
   nlines = 0;
-	for(i=0; i<n; i++)
+  for (i = 0; i < n; i++)
-		if(body[i] == '\n')
+    if (body[i] == '\n')
       nlines++;
   nlines++;
-	lines = emalloc(nlines*sizeof(char*));
+  lines = emalloc(nlines * sizeof(char*));
   nlines = getfields(body, lines, nlines, 0, "\n");
   /* delete leading and trailing blank lines */
   i = 0;
-	while(i<nlines && lines[i][0]=='\0')
+  while (i < nlines && lines[i][0] == '\0')
     i++;
-	while(i<nlines && lines[nlines-1][0]=='\0')
+  while (i < nlines && lines[nlines - 1][0] == '\0')
     nlines--;
-	while(i < nlines){
+  while (i < nlines) {
-		fsprint(fid, ">%s%s\n", lines[i][0]=='>'? "" : " ", lines[i]);
+    fsprint(fid, ">%s%s\n", lines[i][0] == '>' ? "" : " ", lines[i]);
     i++;
   }
   free(lines);
@@ -67,21 +67,20 @@ quote(Message *m, CFid *fid, char *dir, char *quotetext)
   return 1;
 }
 
-void
+void mkreply(
-mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
+  Message* m, char* label, char* to, Plumbattr* attr, char* quotetext) {
-{
   char buf[100];
-	CFid *fd;
+  CFid* fd;
-	Message *r;
+  Message* r;
   char *dir, *t;
   int quotereply;
-	Plumbattr *a;
+  Plumbattr* a;
 
   quotereply = (label[0] == 'Q');
 
-	if(quotereply && m && m->replywinid > 0){
+  if (quotereply && m && m->replywinid > 0) {
     snprint(buf, sizeof buf, "%d/body", m->replywinid);
-		if((fd = fsopen(acmefs, buf, OWRITE)) != nil){
+    if ((fd = fsopen(acmefs, buf, OWRITE)) != nil) {
       dir = estrstrdup(mbox.name, m->name);
       quote(m, fd, dir, quotetext);
       free(dir);
@@ -91,67 +90,69 @@ mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
 
   r = emalloc(sizeof(Message));
   r->isreply = 1;
-	if(m != nil)
+  if (m != nil)
     r->replyname = estrdup(m->name);
   r->next = replies.head;
   r->prev = nil;
-	if(replies.head != nil)
+  if (replies.head != nil)
     replies.head->prev = r;
   replies.head = r;
-	if(replies.tail == nil)
+  if (replies.tail == nil)
     replies.tail = r;
-	r->name = emalloc(strlen(mbox.name)+strlen(label)+10);
+  r->name = emalloc(strlen(mbox.name) + strlen(label) + 10);
   sprint(r->name, "%s%s%d", mbox.name, label, ++replyid);
   r->w = newwindow();
-	if(m)
+  if (m)
     m->replywinid = r->w->id;
   winname(r->w, r->name);
   ctlprint(r->w->ctl, "cleartag");
-	wintagwrite(r->w, "fmt Look Post Undo", 4+5+5+4);
+  wintagwrite(r->w, "fmt Look Post Undo", 4 + 5 + 5 + 4);
   r->tagposted = 1;
   threadcreate(mesgctl, r, STACK);
   winopenbody(r->w, OWRITE);
-	if(to!=nil && to[0]!='\0')
+  if (to != nil && to[0] != '\0')
     fsprint(r->w->body, "%s\n", to);
-	for(a=attr; a; a=a->next)
+  for (a = attr; a; a = a->next)
     fsprint(r->w->body, "%s: %s\n", a->name, a->value);
   dir = nil;
-	if(m != nil){
+  if (m != nil) {
     dir = estrstrdup(mbox.name, m->name);
-		if(to == nil && attr == nil){
+    if (to == nil && attr == nil) {
       /* Reply goes to replyto; Reply all goes to From and To and CC */
-			if(strstr(label, "all") == nil)
+      if (strstr(label, "all") == nil)
         fsprint(r->w->body, "To: %s\n", m->replyto);
-			else{	/* Replyall */
+      else { /* Replyall */
-				if(strlen(m->from) > 0)
+        if (strlen(m->from) > 0)
           fsprint(r->w->body, "To: %s\n", m->from);
-				if(strlen(m->to) > 0)
+        if (strlen(m->to) > 0)
           fsprint(r->w->body, "To: %s\n", m->to);
-				if(strlen(m->cc) > 0)
+        if (strlen(m->cc) > 0)
           fsprint(r->w->body, "CC: %s\n", m->cc);
       }
     }
-		if(strlen(m->subject) > 0){
+    if (strlen(m->subject) > 0) {
       t = "Subject: Re: ";
-			if(strlen(m->subject) >= 3)
+      if (strlen(m->subject) >= 3)
-				if(tolower(m->subject[0])=='r' && tolower(m->subject[1])=='e' && m->subject[2]==':')
+        if (
+          tolower(m->subject[0]) == 'r' && tolower(m->subject[1]) == 'e' &&
+          m->subject[2] == ':')
           t = "Subject: ";
       fsprint(r->w->body, "%s%s\n", t, m->subject);
     }
-		if(!quotereply){
+    if (!quotereply) {
       fsprint(r->w->body, "Include: %sraw\n", dir);
       free(dir);
     }
   }
   fsprint(r->w->body, "\n");
-	if(m == nil)
+  if (m == nil)
     fsprint(r->w->body, "\n");
-	else if(quotereply){
+  else if (quotereply) {
     quote(m, r->w->body, dir, quotetext);
     free(dir);
   }
   winclosebody(r->w);
-	if(m==nil && (to==nil || to[0]=='\0'))
+  if (m == nil && (to == nil || to[0] == '\0'))
     winselect(r->w, "0", 0);
   else
     winselect(r->w, "$", 0);
@@ -159,14 +160,12 @@ mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
   windormant(r->w);
 }
 
-void
+void delreply(Message* m) {
-delreply(Message *m)
+  if (m->next == nil)
-{
-	if(m->next == nil)
     replies.tail = m->prev;
   else
     m->next->prev = m->prev;
-	if(m->prev == nil)
+  if (m->prev == nil)
     replies.head = m->next;
   else
     m->prev->next = m->next;
@@ -174,20 +173,19 @@ delreply(Message *m)
   free(m);
 }
 
-/* copy argv to stack and free the incoming strings, so we don't leak argument vectors */
+/* copy argv to stack and free the incoming strings, so we don't leak argument
-void
+ * vectors */
-buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
+void buildargv(char** inargv, char* argv[NARGS + 1], char args[NARGCHAR]) {
-{
   int i, n;
   char *s, *a;
 
   s = args;
-	for(i=0; i<NARGS; i++){
+  for (i = 0; i < NARGS; i++) {
     a = inargv[i];
-		if(a == nil)
+    if (a == nil)
       break;
-		n = strlen(a)+1;
+    n = strlen(a) + 1;
-		if((s-args)+n >= NARGCHAR)	/* too many characters */
+    if ((s - args) + n >= NARGCHAR) /* too many characters */
       break;
     argv[i] = s;
     memmove(s, a, n);
@@ -197,13 +195,11 @@ buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
   argv[i] = nil;
 }
 
-void
+void execproc(void* v) {
-execproc(void *v)
+  struct Exec* e;
-{
-	struct Exec *e;
   int p[2], q[2];
-	char *prog;
+  char* prog;
-	char *argv[NARGS+1], args[NARGCHAR];
+  char *argv[NARGS + 1], args[NARGCHAR];
   int fd[3];
 
   e = v;
@@ -214,7 +210,7 @@ execproc(void *v)
   prog = e->prog; /* known not to be malloc'ed */
 
   fd[0] = dup(p[0], -1);
-	if(q[0])
+  if (q[0])
     fd[1] = dup(q[1], -1);
   else
     fd[1] = dup(1, -1);
@@ -234,76 +230,53 @@ execproc(void *v)
   threadexits("can't exec");
 }
 
-enum{
+enum { ATTACH, BCC, CC, FROM, INCLUDE, TO };
-	ATTACH,
-	BCC,
-	CC,
-	FROM,
-	INCLUDE,
-	TO
-};
 
-char *headers[] = {
+char* headers[] = {"attach:", "bcc:", "cc:", "from:", "include:", "to:", nil};
-	"attach:",
-	"bcc:",
-	"cc:",
-	"from:",
-	"include:",
-	"to:",
-	nil
-};
 
-int
+int whichheader(char* h) {
-whichheader(char *h)
-{
   int i;
 
-	for(i=0; headers[i]!=nil; i++)
+  for (i = 0; headers[i] != nil; i++)
-		if(cistrcmp(h, headers[i]) == 0)
+    if (cistrcmp(h, headers[i]) == 0)
       return i;
   return -1;
 }
 
-char *tolist[200];
+char* tolist[200];
-char	*cclist[200];
+char* cclist[200];
-char	*bcclist[200];
+char* bcclist[200];
 int ncc, nbcc, nto;
-char	*attlist[200];
+char* attlist[200];
 char included[200];
 
-int
+int addressed(char* name) {
-addressed(char *name)
-{
   int i;
 
-	for(i=0; i<nto; i++)
+  for (i = 0; i < nto; i++)
-		if(strcmp(name, tolist[i]) == 0)
+    if (strcmp(name, tolist[i]) == 0)
       return 1;
-	for(i=0; i<ncc; i++)
+  for (i = 0; i < ncc; i++)
-		if(strcmp(name, cclist[i]) == 0)
+    if (strcmp(name, cclist[i]) == 0)
       return 1;
-	for(i=0; i<nbcc; i++)
+  for (i = 0; i < nbcc; i++)
-		if(strcmp(name, bcclist[i]) == 0)
+    if (strcmp(name, bcclist[i]) == 0)
       return 1;
   return 0;
 }
 
-char*
+char* skipbl(char* s, char* e) {
-skipbl(char *s, char *e)
+  while (s < e) {
-{
+    if (*s != ' ' && *s != '\t' && *s != ',')
-	while(s < e){
-		if(*s!=' ' && *s!='\t' && *s!=',')
       break;
     s++;
   }
   return s;
 }
 
-char*
+char* findbl(char* s, char* e) {
-findbl(char *s, char *e)
+  while (s < e) {
-{
+    if (*s == ' ' || *s == '\t' || *s == ',')
-	while(s < e){
-		if(*s==' ' || *s=='\t' || *s==',')
       break;
     s++;
   }
@@ -311,75 +284,70 @@ findbl(char *s, char *e)
 }
 
 /*
- * comma-separate possibly blank-separated strings in line; e points before newline
+ * comma-separate possibly blank-separated strings in line; e points before
+ * newline
  */
-void
+void commas(char* s, char* e) {
-commas(char *s, char *e)
+  char* t;
-{
-	char *t;
 
   /* may have initial blanks */
   s = skipbl(s, e);
-	while(s < e){
+  while (s < e) {
     s = findbl(s, e);
-		if(s == e)
+    if (s == e)
       break;
     t = skipbl(s, e);
-		if(t == e)	/* no more words */
+    if (t == e) /* no more words */
       break;
     /* patch comma */
     *s++ = ',';
-		while(s < t)
+    while (s < t)
       *s++ = ' ';
   }
 }
 
-int
+int print2(int fd, int ofd, char* fmt, ...) {
-print2(int fd, int ofd, char *fmt, ...)
-{
   int m, n;
-	char *s;
+  char* s;
   va_list arg;
 
   va_start(arg, fmt);
   s = vsmprint(fmt, arg);
   va_end(arg);
-	if(s == nil)
+  if (s == nil)
     return -1;
   m = strlen(s);
   n = write(fd, s, m);
-	if(ofd > 0)
+  if (ofd > 0)
     write(ofd, s, m);
   return n;
 }
 
-void
+void write2(int fd, int ofd, char* buf, int n, int nofrom) {
-write2(int fd, int ofd, char *buf, int n, int nofrom)
-{
   char *from, *p;
   int m;
 
   write(fd, buf, n);
 
-	if(ofd <= 0)
+  if (ofd <= 0)
     return;
 
-	if(nofrom == 0){
+  if (nofrom == 0) {
     write(ofd, buf, n);
     return;
   }
 
   /* need to escape leading From lines to avoid corrupting 'outgoing' mailbox */
-	for(p=buf; *p; p+=m){
+  for (p = buf; *p; p += m) {
     from = cistrstr(p, "from");
-		if(from == nil)
+    if (from == nil)
       m = n;
     else
       m = from - p;
-		if(m > 0)
+    if (m > 0)
       write(ofd, p, m);
-		if(from){
+    if (from) {
-			if(p==buf || from[-1]=='\n')
+      if (p == buf || from[-1] == '\n')
         write(ofd, " ", 1); /* escape with space if From is at start of line */
       write(ofd, from, 4);
       m += 4;
@@ -388,13 +356,11 @@ write2(int fd, int ofd, char *buf, int n, int nofrom)
   }
 }
 
-void
+void mesgsend(Message* m) {
-mesgsend(Message *m)
-{
   char *s, *body, *to;
   int i, j, h, n, natt, p[2];
-	struct Exec *e;
+  struct Exec* e;
-	Channel *sync;
+  Channel* sync;
   int first, nfld, delit, ofd;
   char *copy, *fld[100], *now;
 
@@ -406,83 +372,83 @@ mesgsend(Message *m)
   nbcc = 0;
   first = 1;
   to = body;
-	for(;;){
+  for (;;) {
-		for(s=to; *s!='\n'; s++)
+    for (s = to; *s != '\n'; s++)
-			if(*s == '\0'){
+      if (*s == '\0') {
         free(body);
         return;
       }
-		if(s++ == to)	/* blank line */
+    if (s++ == to) /* blank line */
       break;
     /* make copy of line to tokenize */
-		copy = emalloc(s-to);
+    copy = emalloc(s - to);
-		memmove(copy, to, s-to);
+    memmove(copy, to, s - to);
-		copy[s-to-1] = '\0';
+    copy[s - to - 1] = '\0';
     nfld = tokenizec(copy, fld, nelem(fld), ", \t");
-		if(nfld == 0){
+    if (nfld == 0) {
       free(copy);
       break;
     }
-		n -= s-to;
+    n -= s - to;
-		switch(h = whichheader(fld[0])){
+    switch (h = whichheader(fld[0])) {
       case TO:
       case FROM:
         delit = 1;
-			commas(to+strlen(fld[0]), s-1);
+        commas(to + strlen(fld[0]), s - 1);
-			for(i=1; i<nfld && nto<nelem(tolist); i++)
+        for (i = 1; i < nfld && nto < nelem(tolist); i++)
-				if(!addressed(fld[i]))
+          if (!addressed(fld[i]))
             tolist[nto++] = estrdup(fld[i]);
         break;
       case BCC:
         delit = 1;
-			commas(to+strlen(fld[0]), s-1);
+        commas(to + strlen(fld[0]), s - 1);
-			for(i=1; i<nfld && nbcc<nelem(bcclist); i++)
+        for (i = 1; i < nfld && nbcc < nelem(bcclist); i++)
-				if(!addressed(fld[i]))
+          if (!addressed(fld[i]))
             bcclist[nbcc++] = estrdup(fld[i]);
         break;
       case CC:
         delit = 1;
-			commas(to+strlen(fld[0]), s-1);
+        commas(to + strlen(fld[0]), s - 1);
-			for(i=1; i<nfld && ncc<nelem(cclist); i++)
+        for (i = 1; i < nfld && ncc < nelem(cclist); i++)
-				if(!addressed(fld[i]))
+          if (!addressed(fld[i]))
             cclist[ncc++] = estrdup(fld[i]);
         break;
       case ATTACH:
       case INCLUDE:
         delit = 1;
-			for(i=1; i<nfld && natt<nelem(attlist); i++){
+        for (i = 1; i < nfld && natt < nelem(attlist); i++) {
           attlist[natt] = estrdup(fld[i]);
           included[natt++] = (h == INCLUDE);
         }
         break;
       default:
-			if(first){
+        if (first) {
           delit = 1;
-				for(i=0; i<nfld && nto<nelem(tolist); i++)
+          for (i = 0; i < nfld && nto < nelem(tolist); i++)
             tolist[nto++] = estrdup(fld[i]);
-			}else	/* ignore it */
+        } else /* ignore it */
           delit = 0;
         break;
     }
-		if(delit){
+    if (delit) {
       /* delete line from body */
-			memmove(to, s, n+1);
+      memmove(to, s, n + 1);
-		}else
+    } else
       to = s;
     free(copy);
     first = 0;
   }
 
-	ofd = open(outgoing, OWRITE|OCEXEC);	/* no error check necessary */
+  ofd = open(outgoing, OWRITE | OCEXEC); /* no error check necessary */
-	if(ofd > 0){
+  if (ofd > 0) {
     /* From dhog Fri Aug 24 22:13:00 EDT 2001 */
     now = ctime(time(0));
     seek(ofd, 0, 2);
     fprint(ofd, "From %s %s", user, now);
     fprint(ofd, "From: %s\n", user);
     fprint(ofd, "Date: %s", now);
-		for(i=0; i<natt; i++)
+    for (i = 0; i < natt; i++)
-			if(included[i])
+      if (included[i])
         fprint(ofd, "Include: %s\n", attlist[i]);
       else
         fprint(ofd, "Attach: %s\n", attlist[i]);
@@ -492,21 +458,21 @@ mesgsend(Message *m)
   }
 
   e = emalloc(sizeof(struct Exec));
-	if(pipe(p) < 0)
+  if (pipe(p) < 0)
     error("can't create pipe: %r");
   e->p[0] = p[0];
   e->p[1] = p[1];
   e->prog = unsharp("#9/bin/upas/marshal");
-	e->argv = emalloc((1+1+2+4*natt+1)*sizeof(char*));
+  e->argv = emalloc((1 + 1 + 2 + 4 * natt + 1) * sizeof(char*));
   e->argv[0] = estrdup("marshal");
   e->argv[1] = estrdup("-8");
   j = 2;
-	if(m->replyname){
+  if (m->replyname) {
     e->argv[j++] = estrdup("-R");
     e->argv[j++] = estrstrdup(mbox.name, m->replyname);
   }
-	for(i=0; i<natt; i++){
+  for (i = 0; i < natt; i++) {
-		if(included[i])
+    if (included[i])
       e->argv[j++] = estrdup("-A");
     else
       e->argv[j++] = estrdup("-a");
@@ -519,55 +485,55 @@ mesgsend(Message *m)
   /* close(p[0]); */
 
   /* using marshal -8, so generate rfc822 headers */
-	if(nto > 0){
+  if (nto > 0) {
     print2(p[1], ofd, "To: ");
-		for(i=0; i<nto-1; i++)
+    for (i = 0; i < nto - 1; i++)
       print2(p[1], ofd, "%s, ", tolist[i]);
     print2(p[1], ofd, "%s\n", tolist[i]);
   }
-	if(ncc > 0){
+  if (ncc > 0) {
     print2(p[1], ofd, "CC: ");
-		for(i=0; i<ncc-1; i++)
+    for (i = 0; i < ncc - 1; i++)
       print2(p[1], ofd, "%s, ", cclist[i]);
     print2(p[1], ofd, "%s\n", cclist[i]);
   }
-	if(nbcc > 0){
+  if (nbcc > 0) {
     print2(p[1], ofd, "BCC: ");
-		for(i=0; i<nbcc-1; i++)
+    for (i = 0; i < nbcc - 1; i++)
       print2(p[1], ofd, "%s, ", bcclist[i]);
     print2(p[1], ofd, "%s\n", bcclist[i]);
   }
 
   i = strlen(body);
-	if(i > 0)
+  if (i > 0)
     write2(p[1], ofd, body, i, 1);
 
   /* guarantee a blank line, to ensure attachments are separated from body */
-	if(i==0 || body[i-1]!='\n')
+  if (i == 0 || body[i - 1] != '\n')
     write2(p[1], ofd, "\n\n", 2, 0);
-	else if(i>1 && body[i-2]!='\n')
+  else if (i > 1 && body[i - 2] != '\n')
     write2(p[1], ofd, "\n", 1, 0);
 
   /* these look like pseudo-attachments in the "outgoing" box */
-	if(ofd>0 && natt>0){
+  if (ofd > 0 && natt > 0) {
-		for(i=0; i<natt; i++)
+    for (i = 0; i < natt; i++)
-			if(included[i])
+      if (included[i])
         fprint(ofd, "=====> Include: %s\n", attlist[i]);
       else
         fprint(ofd, "=====> Attach: %s\n", attlist[i]);
   }
-	if(ofd > 0)
+  if (ofd > 0)
     write(ofd, "\n", 1);
 
-	for(i=0; i<natt; i++)
+  for (i = 0; i < natt; i++)
     free(attlist[i]);
   close(ofd);
   close(p[1]);
   free(body);
 
-	if(m->replyname != nil)
+  if (m->replyname != nil)
     mesgmenumark(mbox.w, m->replyname, "\t[replied]");
-	if(m->name[0] == '/')
+  if (m->name[0] == '/')
     s = estrdup(m->name);
   else
     s = estrstrdup(mbox.name, m->name);

mail/util.c

@@ -6,59 +6,49 @@
 #include <9pclient.h>
 #include "dat.h"
 
-void*
+void* emalloc(uint n) {
-emalloc(uint n)
+  void* p;
-{
-	void *p;
 
   p = malloc(n);
-	if(p == nil)
+  if (p == nil)
     error("can't malloc: %r");
   memset(p, 0, n);
   setmalloctag(p, getcallerpc(&n));
   return p;
 }
 
-void*
+void* erealloc(void* p, uint n) {
-erealloc(void *p, uint n)
-{
   p = realloc(p, n);
-	if(p == nil)
+  if (p == nil)
     error("can't realloc: %r");
   setmalloctag(p, getcallerpc(&n));
   return p;
 }
 
-char*
+char* estrdup(char* s) {
-estrdup(char *s)
+  char* t;
-{
-	char *t;
 
-	t = emalloc(strlen(s)+1);
+  t = emalloc(strlen(s) + 1);
   strcpy(t, s);
   return t;
 }
 
-char*
+char* estrstrdup(char* s, char* t) {
-estrstrdup(char *s, char *t)
+  char* u;
-{
-	char *u;
 
-	u = emalloc(strlen(s)+strlen(t)+1);
+  u = emalloc(strlen(s) + strlen(t) + 1);
   strcpy(u, s);
   strcat(u, t);
   return u;
 }
 
-char*
+char* eappend(char* s, char* sep, char* t) {
-eappend(char *s, char *sep, char *t)
+  char* u;
-{
-	char *u;
 
-	if(t == nil)
+  if (t == nil)
     u = estrstrdup(s, sep);
-	else{
+  else {
-		u = emalloc(strlen(s)+strlen(sep)+strlen(t)+1);
+    u = emalloc(strlen(s) + strlen(sep) + strlen(t) + 1);
     strcpy(u, s);
     strcat(u, sep);
     strcat(u, t);
@@ -67,17 +57,13 @@ eappend(char *s, char *sep, char *t)
   return u;
 }
 
-char*
+char* egrow(char* s, char* sep, char* t) {
-egrow(char *s, char *sep, char *t)
-{
   s = eappend(s, sep, t);
   free(t);
   return s;
 }
 
-void
+void error(char* fmt, ...) {
-error(char *fmt, ...)
-{
   Fmt f;
   char buf[64];
   va_list arg;
@@ -92,16 +78,13 @@ error(char *fmt, ...)
   threadexitsall(fmt);
 }
 
-void
+void ctlprint(CFid* fd, char* fmt, ...) {
-ctlprint(CFid *fd, char *fmt, ...)
-{
   int n;
   va_list arg;
 
   va_start(arg, fmt);
   n = fsvprint(fd, fmt, arg);
   va_end(arg);
-	if(n <= 0)
+  if (n <= 0)
     error("control file write error: %r");
 }
-

mail/win.c

@@ -6,15 +6,13 @@
 #include <9pclient.h>
 #include "dat.h"
 
-Window*
+Window* newwindow(void) {
-newwindow(void)
-{
   char buf[12];
-	Window *w;
+  Window* w;
 
   w = emalloc(sizeof(Window));
-	w->ctl = fsopen(acmefs, "new/ctl", ORDWR|OCEXEC);
+  w->ctl = fsopen(acmefs, "new/ctl", ORDWR | OCEXEC);
-	if(w->ctl == nil || fsread(w->ctl, buf, 12)!=12)
+  if (w->ctl == nil || fsread(w->ctl, buf, 12) != 12)
     error("can't open window ctl file: %r");
 
   w->id = atoi(buf);
@@ -27,19 +25,15 @@ newwindow(void)
   return w;
 }
 
-void
+void winincref(Window* w) {
-winincref(Window *w)
-{
   qlock(&w->lk);
   ++w->ref;
   qunlock(&w->lk);
 }
 
-void
+void windecref(Window* w) {
-windecref(Window *w)
-{
   qlock(&w->lk);
-	if(--w->ref > 0){
+  if (--w->ref > 0) {
     qunlock(&w->lk);
     return;
   }
@@ -48,119 +42,98 @@ windecref(Window *w)
   free(w);
 }
 
-void
+void winsetdump(Window* w, char* dir, char* cmd) {
-winsetdump(Window *w, char *dir, char *cmd)
+  if (dir != nil)
-{
-	if(dir != nil)
     ctlprint(w->ctl, "dumpdir %s\n", dir);
-	if(cmd != nil)
+  if (cmd != nil)
     ctlprint(w->ctl, "dump %s\n", cmd);
 }
 
-void
+void wineventproc(void* v) {
-wineventproc(void *v)
+  Window* w;
-{
-	Window *w;
   int i;
 
   w = v;
-	for(i=0; ; i++){
+  for (i = 0;; i++) {
-		if(i >= NEVENT)
+    if (i >= NEVENT)
       i = 0;
     wingetevent(w, &w->e[i]);
     sendp(w->cevent, &w->e[i]);
   }
 }
 
-static CFid*
+static CFid* winopenfile1(Window* w, char* f, int m) {
-winopenfile1(Window *w, char *f, int m)
-{
   char buf[64];
   CFid* fd;
 
   sprint(buf, "%d/%s", w->id, f);
-	fd = fsopen(acmefs, buf, m|OCEXEC);
+  fd = fsopen(acmefs, buf, m | OCEXEC);
-	if(fd == nil)
+  if (fd == nil)
     error("can't open window file %s: %r", f);
   return fd;
 }
 
-CFid*
+CFid* winopenfile(Window* w, char* f) { return winopenfile1(w, f, ORDWR); }
-winopenfile(Window *w, char *f)
-{
-	return winopenfile1(w, f, ORDWR);
-}
 
-void
+void wintagwrite(Window* w, char* s, int n) {
-wintagwrite(Window *w, char *s, int n)
-{
   CFid* fid;
 
   fid = winopenfile(w, "tag");
-	if(fswrite(fid, s, n) != n)
+  if (fswrite(fid, s, n) != n)
     error("tag write: %r");
   fsclose(fid);
 }
 
-void
+void winname(Window* w, char* s) {
-winname(Window *w, char *s)
-{
   int len;
   char *ns, *sp;
   Rune r = L'␣'; /* visible space */
 
   len = 0;
-	ns = emalloc(strlen(s)*runelen(r) + 1);
+  ns = emalloc(strlen(s) * runelen(r) + 1);
-	for(sp = s; *sp != '\0'; sp++, len++){
+  for (sp = s; *sp != '\0'; sp++, len++) {
-		if(isspace(*sp)){
+    if (isspace(*sp)) {
-			len += runetochar(ns+len, &r)-1;
+      len += runetochar(ns + len, &r) - 1;
       continue;
     }
-		*(ns+len) = *sp;
+    *(ns + len) = *sp;
   }
   ctlprint(w->ctl, "name %s\n", ns);
   free(ns);
   return;
 }
 
-void
+void winopenbody(Window* w, int mode) {
-winopenbody(Window *w, int mode)
-{
   char buf[256];
   CFid* fid;
 
   sprint(buf, "%d/body", w->id);
-	fid = fsopen(acmefs, buf, mode|OCEXEC);
+  fid = fsopen(acmefs, buf, mode | OCEXEC);
   w->body = fid;
-	if(w->body == nil)
+  if (w->body == nil)
     error("can't open window body file: %r");
 }
 
-void
+void winclosebody(Window* w) {
-winclosebody(Window *w)
+  if (w->body != nil) {
-{
-	if(w->body != nil){
     fsclose(w->body);
     w->body = nil;
   }
 }
 
-void
+void winwritebody(Window* w, char* s, int n) {
-winwritebody(Window *w, char *s, int n)
+  if (w->body == nil)
-{
-	if(w->body == nil)
     winopenbody(w, OWRITE);
-	if(fswrite(w->body, s, n) != n)
+  if (fswrite(w->body, s, n) != n)
     error("write error to window: %r");
 }
 
-int
+int wingetec(Window* w) {
-wingetec(Window *w)
+  if (w->nbuf == 0) {
-{
-	if(w->nbuf == 0){
     w->nbuf = fsread(w->event, w->buf, sizeof w->buf);
-		if(w->nbuf <= 0){
+    if (w->nbuf <= 0) {
-			/* probably because window has exited, and only called by wineventproc, so just shut down */
+      /* probably because window has exited, and only called by wineventproc, so
+       * just shut down */
       windecref(w);
       threadexits(nil);
     }
@@ -170,30 +143,26 @@ wingetec(Window *w)
   return *w->bufp++;
 }
 
-int
+int wingeten(Window* w) {
-wingeten(Window *w)
-{
   int n, c;
 
   n = 0;
-	while('0'<=(c=wingetec(w)) && c<='9')
+  while ('0' <= (c = wingetec(w)) && c <= '9')
-		n = n*10+(c-'0');
+    n = n * 10 + (c - '0');
-	if(c != ' ')
+  if (c != ' ')
     error("event number syntax");
   return n;
 }
 
-int
+int wingeter(Window* w, char* buf, int* nb) {
-wingeter(Window *w, char *buf, int *nb)
-{
   Rune r;
   int n;
 
   r = wingetec(w);
   buf[0] = r;
   n = 1;
-	if(r >= Runeself) {
+  if (r >= Runeself) {
-		while(!fullrune(buf, n))
+    while (!fullrune(buf, n))
       buf[n++] = wingetec(w);
     chartorune(&r, buf);
   }
@@ -201,9 +170,7 @@ wingeter(Window *w, char *buf, int *nb)
   return r;
 }
 
-void
+void wingetevent(Window* w, Event* e) {
-wingetevent(Window *w, Event *e)
-{
   int i, nb;
 
   e->c1 = wingetec(w);
@@ -212,49 +179,47 @@ wingetevent(Window *w, Event *e)
   e->q1 = wingeten(w);
   e->flag = wingeten(w);
   e->nr = wingeten(w);
-	if(e->nr > EVENTSIZE)
+  if (e->nr > EVENTSIZE)
     error("event string too long");
   e->nb = 0;
-	for(i=0; i<e->nr; i++){
+  for (i = 0; i < e->nr; i++) {
-		e->r[i] = wingeter(w, e->b+e->nb, &nb);
+    e->r[i] = wingeter(w, e->b + e->nb, &nb);
     e->nb += nb;
   }
   e->r[e->nr] = 0;
   e->b[e->nb] = 0;
-	if(wingetec(w) != '\n')
+  if (wingetec(w) != '\n')
     error("event syntax error");
 }
 
-void
+void winwriteevent(Window* w, Event* e) {
-winwriteevent(Window *w, Event *e)
-{
   fsprint(w->event, "%c%c%d %d\n", e->c1, e->c2, e->q0, e->q1);
 }
 
-void
+void winread(Window* w, uint q0, uint q1, char* data) {
-winread(Window *w, uint q0, uint q1, char *data)
-{
   int m, n, nr;
   char buf[256];
 
-	if(w->addr == nil)
+  if (w->addr == nil)
     w->addr = winopenfile(w, "addr");
-	if(w->data == nil)
+  if (w->data == nil)
     w->data = winopenfile(w, "data");
   m = q0;
-	while(m < q1){
+  while (m < q1) {
     n = sprint(buf, "#%d", m);
-		if(fswrite(w->addr, buf, n) != n)
+    if (fswrite(w->addr, buf, n) != n)
       error("error writing addr: %r");
     n = fsread(w->data, buf, sizeof buf);
-		if(n <= 0)
+    if (n <= 0)
       error("reading data: %r");
     nr = utfnlen(buf, n);
-		while(m+nr >q1){
+    while (m + nr > q1) {
-			do; while(n>0 && (buf[--n]&0xC0)==0x80);
+      do
+        ;
+      while (n > 0 && (buf[--n] & 0xC0) == 0x80);
       --nr;
     }
-		if(n == 0)
+    if (n == 0)
       break;
     memmove(data, buf, n);
     data += n;
@@ -263,30 +228,25 @@ winread(Window *w, uint q0, uint q1, char *data)
   }
 }
 
-void
+void windormant(Window* w) {
-windormant(Window *w)
+  if (w->addr != nil) {
-{
-	if(w->addr != nil){
     fsclose(w->addr);
     w->addr = nil;
   }
-	if(w->body != nil){
+  if (w->body != nil) {
     fsclose(w->body);
     w->body = nil;
   }
-	if(w->data != nil){
+  if (w->data != nil) {
     fsclose(w->data);
     w->data = nil;
   }
 }
 
-
+int windel(Window* w, int sure) {
-int
+  if (sure)
-windel(Window *w, int sure)
-{
-	if(sure)
     fswrite(w->ctl, "delete\n", 7);
-	else if(fswrite(w->ctl, "del\n", 4) != 4)
+  else if (fswrite(w->ctl, "del\n", 4) != 4)
     return 0;
   /* event proc will die due to read error from event file */
   windormant(w);
@@ -295,54 +255,47 @@ windel(Window *w, int sure)
   return 1;
 }
 
-void
+void winclean(Window* w) { ctlprint(w->ctl, "clean\n"); }
-winclean(Window *w)
-{
-	ctlprint(w->ctl, "clean\n");
-}
 
-int
+int winsetaddr(Window* w, char* addr, int errok) {
-winsetaddr(Window *w, char *addr, int errok)
+  if (w->addr == nil)
-{
-	if(w->addr == nil)
     w->addr = winopenfile(w, "addr");
-	if(fswrite(w->addr, addr, strlen(addr)) < 0){
+  if (fswrite(w->addr, addr, strlen(addr)) < 0) {
-		if(!errok)
+    if (!errok)
       error("error writing addr(%s): %r", addr);
     return 0;
   }
   return 1;
 }
 
-int
+int winselect(Window* w, char* addr, int errok) {
-winselect(Window *w, char *addr, int errok)
+  if (winsetaddr(w, addr, errok)) {
-{
-	if(winsetaddr(w, addr, errok)){
     ctlprint(w->ctl, "dot=addr\n");
     return 1;
   }
   return 0;
 }
 
-char*
+char* winreadbody(
-winreadbody(Window *w, int *np)	/* can't use readfile because acme doesn't report the length */
+  Window* w,
+  int* np) /* can't use readfile because acme doesn't report the length */
 {
-	char *s;
+  char* s;
   int m, na, n;
 
-	if(w->body != nil)
+  if (w->body != nil)
     winclosebody(w);
   winopenbody(w, OREAD);
   s = nil;
   na = 0;
   n = 0;
-	for(;;){
+  for (;;) {
-		if(na < n+512){
+    if (na < n + 512) {
       na += 1024;
-			s = realloc(s, na+1);
+      s = realloc(s, na + 1);
     }
-		m = fsread(w->body, s+n, na-n);
+    m = fsread(w->body, s + n, na - n);
-		if(m <= 0)
+    if (m <= 0)
       break;
     n += m;
   }
@@ -352,25 +305,23 @@ winreadbody(Window *w, int *np)	/* can't use readfile because acme doesn't repor
   return s;
 }
 
-char*
+char* winselection(Window* w) {
-winselection(Window *w)
-{
   int m, n;
-	char *buf;
+  char* buf;
   char tmp[256];
   CFid* fid;
 
   fid = winopenfile1(w, "rdsel", OREAD);
-	if(fid == nil)
+  if (fid == nil)
     error("can't open rdsel: %r");
   n = 0;
   buf = nil;
-	for(;;){
+  for (;;) {
     m = fsread(fid, tmp, sizeof tmp);
-		if(m <= 0)
+    if (m <= 0)
       break;
-		buf = erealloc(buf, n+m+1);
+    buf = erealloc(buf, n + m + 1);
-		memmove(buf+n, tmp, m);
+    memmove(buf + n, tmp, m);
     n += m;
     buf[n] = '\0';
   }

regx.c

@@ -13,39 +13,37 @@
 #include "fns.h"
 
 Rangeset sel;
-Rune		*lastregexp;
+Rune* lastregexp;
 
 /*
  * Machine Information
  */
 typedef struct Inst Inst;
-struct Inst
+struct Inst {
-{
   uint type; /* < OPERATOR ==> literal, otherwise action */
   union {
     int sid;
     int subid;
     int class;
-		Inst *other;
+    Inst* other;
-		Inst *right;
+    Inst* right;
   } u;
-	union{
+  union {
-		Inst *left;
+    Inst* left;
-		Inst *next;
+    Inst* next;
   } u1;
 };
 
 #define NPROG 1024
 Inst program[NPROG];
-Inst	*progp;
+Inst* progp;
-Inst	*startinst;	/* First inst. of program; might not be program[0] */
+Inst* startinst;  /* First inst. of program; might not be program[0] */
-Inst	*bstartinst;	/* same for backwards machine */
+Inst* bstartinst; /* same for backwards machine */
-Channel	*rechan;	/* chan(Inst*) */
+Channel* rechan;  /* chan(Inst*) */
 
 typedef struct Ilist Ilist;
-struct Ilist
+struct Ilist {
-{
+  Inst* inst; /* Instruction of the thread */
-	Inst	*inst;		/* Instruction of the thread */
   Rangeset se;
   uint startp; /* first char of match */
 };
@@ -53,7 +51,7 @@ struct Ilist
 #define NLIST 127
 
 Ilist *tl, *nl;           /* This list, next list */
-Ilist	list[2][NLIST+1];	/* +1 for trailing null */
+Ilist list[2][NLIST + 1]; /* +1 for trailing null */
 static Rangeset sempty;
 
 /*
@@ -63,21 +61,21 @@ static	Rangeset sempty;
  *	0x20000xx are tokens, i.e. operands for operators
  */
 #define OPERATOR 0x1000000 /* Bit set in all operators */
-#define	START		(OPERATOR+0)	/* Start, used for marker on stack */
+#define START (OPERATOR + 0) /* Start, used for marker on stack */
-#define	RBRA		(OPERATOR+1)	/* Right bracket, ) */
+#define RBRA (OPERATOR + 1) /* Right bracket, ) */
-#define	LBRA		(OPERATOR+2)	/* Left bracket, ( */
+#define LBRA (OPERATOR + 2) /* Left bracket, ( */
-#define	OR		(OPERATOR+3)	/* Alternation, | */
+#define OR (OPERATOR + 3) /* Alternation, | */
-#define	CAT		(OPERATOR+4)	/* Concatentation, implicit operator */
+#define CAT (OPERATOR + 4) /* Concatentation, implicit operator */
-#define	STAR		(OPERATOR+5)	/* Closure, * */
+#define STAR (OPERATOR + 5) /* Closure, * */
-#define	PLUS		(OPERATOR+6)	/* a+ == aa* */
+#define PLUS (OPERATOR + 6) /* a+ == aa* */
-#define	QUEST		(OPERATOR+7)	/* a? == a|nothing, i.e. 0 or 1 a's */
+#define QUEST (OPERATOR + 7) /* a? == a|nothing, i.e. 0 or 1 a's */
 #define ANY 0x2000000 /* Any character but newline, . */
-#define	NOP		(ANY+1)	/* No operation, internal use only */
+#define NOP (ANY + 1) /* No operation, internal use only */
-#define	BOL		(ANY+2)	/* Beginning of line, ^ */
+#define BOL (ANY + 2) /* Beginning of line, ^ */
-#define	EOL		(ANY+3)	/* End of line, $ */
+#define EOL (ANY + 3) /* End of line, $ */
-#define	CCLASS		(ANY+4)	/* Character class, [] */
+#define CCLASS (ANY + 4) /* Character class, [] */
-#define	NCCLASS		(ANY+5)	/* Negated character class, [^] */
+#define NCCLASS (ANY + 5) /* Negated character class, [^] */
-#define	END		(ANY+0x77)	/* Terminate: match found */
+#define END (ANY + 0x77) /* Terminate: match found */
 
 #define ISATOR OPERATOR
 #define ISAND ANY
@@ -88,36 +86,35 @@ static	Rangeset sempty;
  * Parser Information
  */
 typedef struct Node Node;
-struct Node
+struct Node {
-{
+  Inst* first;
-	Inst	*first;
+  Inst* last;
-	Inst	*last;
 };
 
 #define NSTACK 20
 Node andstack[NSTACK];
-Node	*andp;
+Node* andp;
 int atorstack[NSTACK];
-int	*atorp;
+int* atorp;
 int lastwasand; /* Last token was operand */
 int cursubid;
 int subidstack[NSTACK];
-int	*subidp;
+int* subidp;
 int backwards;
 int nbra;
-Rune	*exprp;		/* pointer to next character in source expression */
+Rune* exprp;      /* pointer to next character in source expression */
 #define DCLASS 10 /* allocation increment */
 int nclass; /* number active */
 int Nclass; /* high water mark */
-Rune	**class;
+Rune** class;
 int negateclass;
 
-int	addinst(Ilist *l, Inst *inst, Rangeset *sep);
+int addinst(Ilist* l, Inst* inst, Rangeset* sep);
 void newmatch(Rangeset*);
 void bnewmatch(Rangeset*);
 void pushand(Inst*, Inst*);
 void pushator(int);
-Node	*popand(int);
+Node* popand(int);
 int popator(void);
 void startlex(Rune*);
 int lex(void);
@@ -127,27 +124,21 @@ void	evaluntil(int);
 void optimize(Inst*);
 void bldcclass(void);
 
-void
+void rxinit(void) {
-rxinit(void)
-{
   rechan = chancreate(sizeof(Inst*), 0);
   chansetname(rechan, "rechan");
   lastregexp = runemalloc(1);
 }
 
-void
+void regerror(char* e) {
-regerror(char *e)
-{
   lastregexp[0] = 0;
   warning(nil, "regexp: %s\n", e);
   sendp(rechan, nil);
   threadexits(nil);
 }
 
-Inst *
+Inst* newinst(int t) {
-newinst(int t)
+  if (progp >= &program[NPROG])
-{
-	if(progp >= &program[NPROG])
     regerror("expression too long");
   progp->type = t;
   progp->u1.left = nil;
@@ -155,11 +146,9 @@ newinst(int t)
   return progp++;
 }
 
-void
+void realcompile(void* arg) {
-realcompile(void *arg)
-{
   int token;
-	Rune *s;
+  Rune* s;
 
   threadsetname("regcomp");
   s = arg;
@@ -170,9 +159,9 @@ realcompile(void *arg)
   cursubid = 0;
   lastwasand = FALSE;
   /* Start with a low priority operator to prime parser */
-	pushator(START-1);
+  pushator(START - 1);
-	while((token=lex()) != END){
+  while ((token = lex()) != END) {
-		if((token&ISATOR) == OPERATOR)
+    if ((token & ISATOR) == OPERATOR)
       operator(token);
     else
       operand(token);
@@ -182,7 +171,7 @@ realcompile(void *arg)
   /* Force END */
   operand(END);
   evaluntil(START);
-	if(nbra)
+  if (nbra)
     regerror("unmatched `('");
   --andp; /* points to first and only operand */
   sendp(rechan, andp->first);
@@ -190,17 +179,15 @@ realcompile(void *arg)
 }
 
 /* r is null terminated */
-int
+int rxcompile(Rune* r) {
-rxcompile(Rune *r)
-{
   int i, nr;
-	Inst *oprogp;
+  Inst* oprogp;
 
-	nr = runestrlen(r)+1;
+  nr = runestrlen(r) + 1;
-	if(runeeq(lastregexp, runestrlen(lastregexp)+1, r, nr)==TRUE)
+  if (runeeq(lastregexp, runestrlen(lastregexp) + 1, r, nr) == TRUE)
     return TRUE;
   lastregexp[0] = 0;
-	for(i=0; i<nclass; i++)
+  for (i = 0; i < nclass; i++)
     free(class[i]);
   nclass = 0;
   progp = program;
@@ -208,14 +195,14 @@ rxcompile(Rune *r)
   bstartinst = nil;
   threadcreate(realcompile, r, STACK);
   startinst = recvp(rechan);
-	if(startinst == nil)
+  if (startinst == nil)
     return FALSE;
   optimize(program);
   oprogp = progp;
   backwards = TRUE;
   threadcreate(realcompile, r, STACK);
   bstartinst = recvp(rechan);
-	if(bstartinst == nil)
+  if (bstartinst == nil)
     return FALSE;
   optimize(oprogp);
   lastregexp = runerealloc(lastregexp, nr);
@@ -223,94 +210,80 @@ rxcompile(Rune *r)
   return TRUE;
 }
 
-void
+void operand(int t) {
-operand(int t)
+  Inst* i;
-{
+  if (lastwasand)
-	Inst *i;
-	if(lastwasand)
     operator(CAT); /* catenate is implicit */
   i = newinst(t);
-	if(t == CCLASS){
+  if (t == CCLASS) {
-		if(negateclass)
+    if (negateclass)
       i->type = NCCLASS;     /* UGH */
-		i->u.class = nclass-1;		/* UGH */
+    i->u.class = nclass - 1; /* UGH */
   }
   pushand(i, i);
   lastwasand = TRUE;
 }
 
-void
+void operator(int t) {
-operator(int t)
+  if (t == RBRA && --nbra < 0)
-{
-	if(t==RBRA && --nbra<0)
     regerror("unmatched `)'");
-	if(t==LBRA){
+  if (t == LBRA) {
     cursubid++; /* silently ignored */
     nbra++;
-		if(lastwasand)
+    if (lastwasand)
       operator(CAT);
-	}else
+  } else
     evaluntil(t);
-	if(t!=RBRA)
+  if (t != RBRA)
     pushator(t);
   lastwasand = FALSE;
-	if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
+  if (t == STAR || t == QUEST || t == PLUS || t == RBRA)
     lastwasand = TRUE; /* these look like operands */
 }
 
-void
+void pushand(Inst* f, Inst* l) {
-pushand(Inst *f, Inst *l)
+  if (andp >= &andstack[NSTACK])
-{
-	if(andp >= &andstack[NSTACK])
     error("operand stack overflow");
   andp->first = f;
   andp->last = l;
   andp++;
 }
 
-void
+void pushator(int t) {
-pushator(int t)
+  if (atorp >= &atorstack[NSTACK])
-{
-	if(atorp >= &atorstack[NSTACK])
     error("operator stack overflow");
-	*atorp++=t;
+  *atorp++ = t;
-	if(cursubid >= NRange)
+  if (cursubid >= NRange)
-		*subidp++= -1;
+    *subidp++ = -1;
   else
-		*subidp++=cursubid;
+    *subidp++ = cursubid;
 }
 
-Node *
+Node* popand(int op) {
-popand(int op)
-{
   char buf[64];
 
-	if(andp <= &andstack[0])
+  if (andp <= &andstack[0])
-		if(op){
+    if (op) {
       sprint(buf, "missing operand for %c", op);
       regerror(buf);
-		}else
+    } else
       regerror("malformed regexp");
   return --andp;
 }
 
-int
+int popator() {
-popator()
+  if (atorp <= &atorstack[0])
-{
-	if(atorp <= &atorstack[0])
     error("operator stack underflow");
   --subidp;
   return *--atorp;
 }
 
-void
+void evaluntil(int pri) {
-evaluntil(int pri)
-{
   Node *op1, *op2, *t;
   Inst *inst1, *inst2;
 
-	while(pri==RBRA || atorp[-1]>=pri){
+  while (pri == RBRA || atorp[-1] >= pri) {
-		switch(popator()){
+    switch (popator()) {
       case LBRA:
         op1 = popand('(');
         inst2 = newinst(RBRA);
@@ -338,7 +311,7 @@ evaluntil(int pri)
       case CAT:
         op2 = popand(0);
         op1 = popand(0);
-			if(backwards && op2->first->type!=END){
+        if (backwards && op2->first->type != END) {
           t = op1;
           op1 = op2;
           op2 = t;
@@ -373,38 +346,31 @@ evaluntil(int pri)
   }
 }
 
-
+void optimize(Inst* start) {
-void
-optimize(Inst *start)
-{
   Inst *inst, *target;
 
-	for(inst=start; inst->type!=END; inst++){
+  for (inst = start; inst->type != END; inst++) {
     target = inst->u1.next;
-		while(target->type == NOP)
+    while (target->type == NOP)
       target = target->u1.next;
     inst->u1.next = target;
   }
 }
 
-void
+void startlex(Rune* s) {
-startlex(Rune *s)
-{
   exprp = s;
   nbra = 0;
 }
 
-
+int lex(void) {
-int
-lex(void){
   int c;
 
   c = *exprp++;
-	switch(c){
+  switch (c) {
     case '\\':
-		if(*exprp)
+      if (*exprp)
-			if((c= *exprp++)=='n')
+        if ((c = *exprp++) == 'n')
-				c='\n';
+          c = '\n';
       break;
     case 0:
       c = END;
@@ -445,79 +411,73 @@ lex(void){
   return c;
 }
 
-int
+int nextrec(void) {
-nextrec(void)
+  if (exprp[0] == 0 || (exprp[0] == '\\' && exprp[1] == 0))
-{
-	if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
     regerror("malformed `[]'");
-	if(exprp[0] == '\\'){
+  if (exprp[0] == '\\') {
     exprp++;
-		if(*exprp=='n'){
+    if (*exprp == 'n') {
       exprp++;
       return '\n';
     }
-		return *exprp++|QUOTED;
+    return *exprp++ | QUOTED;
   }
   return *exprp++;
 }
 
-void
+void bldcclass(void) {
-bldcclass(void)
-{
   int c1, c2, n, na;
-	Rune *classp;
+  Rune* classp;
 
   classp = runemalloc(DCLASS);
   n = 0;
   na = DCLASS;
   /* we have already seen the '[' */
-	if(*exprp == '^'){
+  if (*exprp == '^') {
     classp[n++] = '\n'; /* don't match newline in negate case */
     negateclass = TRUE;
     exprp++;
-	}else
+  } else
     negateclass = FALSE;
-	while((c1 = nextrec()) != ']'){
+  while ((c1 = nextrec()) != ']') {
-		if(c1 == '-'){
+    if (c1 == '-') {
     Error:
       free(classp);
       regerror("malformed `[]'");
     }
-		if(n+4 >= na){		/* 3 runes plus NUL */
+    if (n + 4 >= na) { /* 3 runes plus NUL */
       na += DCLASS;
       classp = runerealloc(classp, na);
     }
-		if(*exprp == '-'){
+    if (*exprp == '-') {
       exprp++; /* eat '-' */
-			if((c2 = nextrec()) == ']')
+      if ((c2 = nextrec()) == ']')
         goto Error;
-			classp[n+0] = Runemax;
+      classp[n + 0] = Runemax;
-			classp[n+1] = c1;
+      classp[n + 1] = c1;
-			classp[n+2] = c2;
+      classp[n + 2] = c2;
       n += 3;
-		}else
+    } else
       classp[n++] = c1 & ~QUOTED;
   }
   classp[n] = 0;
-	if(nclass == Nclass){
+  if (nclass == Nclass) {
     Nclass += DCLASS;
-		class = realloc(class, Nclass*sizeof(Rune*));
+    class = realloc(class, Nclass * sizeof(Rune*));
   }
   class[nclass++] = classp;
 }
 
-int
+int classmatch(int classno, int c, int negate) {
-classmatch(int classno, int c, int negate)
+  Rune* p;
-{
-	Rune *p;
 
   p = class[classno];
-	while(*p){
+  while (*p) {
-		if(*p == Runemax){
+    if (*p == Runemax) {
-			if(p[1]<=c && c<=p[2])
+      if (p[1] <= c && c <= p[2])
         return !negate;
       p += 3;
-		}else if(*p++ == c)
+    } else if (*p++ == c)
       return !negate;
   }
   return negate;
@@ -528,37 +488,29 @@ classmatch(int classno, int c, int negate)
  * 	*l must be pending when addinst called; if *l has been looked
  *		at already, the optimization is a bug.
  */
-int
+int addinst(Ilist* l, Inst* inst, Rangeset* sep) {
-addinst(Ilist *l, Inst *inst, Rangeset *sep)
+  Ilist* p;
-{
-	Ilist *p;
 
-	for(p = l; p->inst; p++){
+  for (p = l; p->inst; p++) {
-		if(p->inst==inst){
+    if (p->inst == inst) {
-			if((sep)->r[0].q0 < p->se.r[0].q0)
+      if ((sep)->r[0].q0 < p->se.r[0].q0)
-				p->se= *sep;	/* this would be bug */
+        p->se = *sep; /* this would be bug */
       return 0;       /* It's already there */
     }
   }
   p->inst = inst;
-	p->se= *sep;
+  p->se = *sep;
-	(p+1)->inst = nil;
+  (p + 1)->inst = nil;
   return 1;
 }
 
-int
+int rxnull(void) { return startinst == nil || bstartinst == nil; }
-rxnull(void)
-{
-	return startinst==nil || bstartinst==nil;
-}
 
 /* either t!=nil or r!=nil, and we match the string in the appropriate place */
-int
+int rxexecute(Text* t, Rune* r, uint startp, uint eof, Rangeset* rp) {
-rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
-{
   int flag;
-	Inst *inst;
+  Inst* inst;
-	Ilist *tlp;
+  Ilist* tlp;
   uint p;
   int nnl, ntl;
   int nc, c;
@@ -570,24 +522,24 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
   startchar = 0;
   wrapped = 0;
   nnl = 0;
-	if(startinst->type<OPERATOR)
+  if (startinst->type < OPERATOR)
     startchar = startinst->type;
   list[0][0].inst = list[1][0].inst = nil;
   sel.r[0].q0 = -1;
-	if(t != nil)
+  if (t != nil)
     nc = t->file->b.nc;
   else
     nc = runestrlen(r);
   /* Execute machine once for each character */
-	for(;;p++){
+  for (;; p++) {
   doloop:
-		if(p>=eof || p>=nc){
+    if (p >= eof || p >= nc) {
-			switch(wrapped++){
+      switch (wrapped++) {
         case 0: /* let loop run one more click */
         case 2:
           break;
         case 1: /* expired; wrap to beginning */
-				if(sel.r[0].q0>=0 || eof!=Infinity)
+          if (sel.r[0].q0 >= 0 || eof != Infinity)
             goto Return;
           list[0][0].inst = list[1][0].inst = nil;
           p = 0;
@@ -596,27 +548,27 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
           goto Return;
       }
       c = 0;
-		}else{
+    } else {
-			if(((wrapped && p>=startp) || sel.r[0].q0>0) && nnl==0)
+      if (((wrapped && p >= startp) || sel.r[0].q0 > 0) && nnl == 0)
         break;
-			if(t != nil)
+      if (t != nil)
         c = textreadc(t, p);
       else
         c = r[p];
     }
     /* fast check for first char */
-		if(startchar && nnl==0 && c!=startchar)
+    if (startchar && nnl == 0 && c != startchar)
       continue;
     tl = list[flag];
-		nl = list[flag^=1];
+    nl = list[flag ^= 1];
     nl->inst = nil;
     ntl = nnl;
     nnl = 0;
-		if(sel.r[0].q0<0 && (!wrapped || p<startp || startp==eof)){
+    if (sel.r[0].q0 < 0 && (!wrapped || p < startp || startp == eof)) {
       /* Add first instruction to this list */
       sempty.r[0].q0 = p;
-			if(addinst(tl, startinst, &sempty))
+      if (addinst(tl, startinst, &sempty))
-			if(++ntl >= NLIST){
+        if (++ntl >= NLIST) {
         Overflow:
           warning(nil, "regexp list overflow\n");
           sel.r[0].q0 = -1;
@@ -624,54 +576,56 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
         }
     }
     /* Execute machine until this list is empty */
-		for(tlp = tl; inst = tlp->inst; tlp++){	/* assignment = */
+    for (tlp = tl; inst = tlp->inst; tlp++) { /* assignment = */
     Switchstmt:
-			switch(inst->type){
+      switch (inst->type) {
         default: /* regular character */
-				if(inst->type==c){
+          if (inst->type == c) {
           Addinst:
-					if(addinst(nl, inst->u1.next, &tlp->se))
+            if (addinst(nl, inst->u1.next, &tlp->se))
-					if(++nnl >= NLIST)
+              if (++nnl >= NLIST)
                 goto Overflow;
           }
           break;
         case LBRA:
-				if(inst->u.subid>=0)
+          if (inst->u.subid >= 0)
             tlp->se.r[inst->u.subid].q0 = p;
           inst = inst->u1.next;
           goto Switchstmt;
         case RBRA:
-				if(inst->u.subid>=0)
+          if (inst->u.subid >= 0)
             tlp->se.r[inst->u.subid].q1 = p;
           inst = inst->u1.next;
           goto Switchstmt;
         case ANY:
-				if(c!='\n')
+          if (c != '\n')
             goto Addinst;
           break;
         case BOL:
-				if(p==0 || (t!=nil && textreadc(t, p-1)=='\n') || (r!=nil && r[p-1]=='\n')){
+          if (
+            p == 0 || (t != nil && textreadc(t, p - 1) == '\n') ||
+            (r != nil && r[p - 1] == '\n')) {
           Step:
             inst = inst->u1.next;
             goto Switchstmt;
           }
           break;
         case EOL:
-				if(c == '\n')
+          if (c == '\n')
             goto Step;
           break;
         case CCLASS:
-				if(c>=0 && classmatch(inst->u.class, c, 0))
+          if (c >= 0 && classmatch(inst->u.class, c, 0))
             goto Addinst;
           break;
         case NCCLASS:
-				if(c>=0 && classmatch(inst->u.class, c, 1))
+          if (c >= 0 && classmatch(inst->u.class, c, 1))
             goto Addinst;
           break;
         case OR:
           /* evaluate right choice later */
-				if(addinst(tlp, inst->u.right, &tlp->se))
+          if (addinst(tlp, inst->u.right, &tlp->se))
-				if(++ntl >= NLIST)
+            if (++ntl >= NLIST)
               goto Overflow;
           /* efficiency: advance and re-evaluate */
           inst = inst->u1.left;
@@ -683,25 +637,22 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
       }
     }
   }
-    Return:
+Return:
   *rp = sel;
   return sel.r[0].q0 >= 0;
 }
 
-void
+void newmatch(Rangeset* sp) {
-newmatch(Rangeset *sp)
+  if (
-{
+    sel.r[0].q0 < 0 || sp->r[0].q0 < sel.r[0].q0 ||
-	if(sel.r[0].q0<0 || sp->r[0].q0<sel.r[0].q0 ||
+    (sp->r[0].q0 == sel.r[0].q0 && sp->r[0].q1 > sel.r[0].q1))
-	   (sp->r[0].q0==sel.r[0].q0 && sp->r[0].q1>sel.r[0].q1))
     sel = *sp;
 }
 
-int
+int rxbexecute(Text* t, uint startp, Rangeset* rp) {
-rxbexecute(Text *t, uint startp, Rangeset *rp)
-{
   int flag;
-	Inst *inst;
+  Inst* inst;
-	Ilist *tlp;
+  Ilist* tlp;
   int p;
   int nnl, ntl;
   int c;
@@ -713,20 +664,20 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
   wrapped = 0;
   p = startp;
   startchar = 0;
-	if(bstartinst->type<OPERATOR)
+  if (bstartinst->type < OPERATOR)
     startchar = bstartinst->type;
   list[0][0].inst = list[1][0].inst = nil;
-	sel.r[0].q0= -1;
+  sel.r[0].q0 = -1;
   /* Execute machine once for each character, including terminal NUL */
-	for(;;--p){
+  for (;; --p) {
   doloop:
-		if(p <= 0){
+    if (p <= 0) {
-			switch(wrapped++){
+      switch (wrapped++) {
         case 0: /* let loop run one more click */
         case 2:
           break;
         case 1: /* expired; wrap to end */
-				if(sel.r[0].q0>=0)
+          if (sel.r[0].q0 >= 0)
             goto Return;
           list[0][0].inst = list[1][0].inst = nil;
           p = t->file->b.nc;
@@ -736,25 +687,25 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
           goto Return;
       }
       c = 0;
-		}else{
+    } else {
-			if(((wrapped && p<=startp) || sel.r[0].q0>0) && nnl==0)
+      if (((wrapped && p <= startp) || sel.r[0].q0 > 0) && nnl == 0)
         break;
-			c = textreadc(t, p-1);
+      c = textreadc(t, p - 1);
     }
     /* fast check for first char */
-		if(startchar && nnl==0 && c!=startchar)
+    if (startchar && nnl == 0 && c != startchar)
       continue;
     tl = list[flag];
-		nl = list[flag^=1];
+    nl = list[flag ^= 1];
     nl->inst = nil;
     ntl = nnl;
     nnl = 0;
-		if(sel.r[0].q0<0 && (!wrapped || p>startp)){
+    if (sel.r[0].q0 < 0 && (!wrapped || p > startp)) {
       /* Add first instruction to this list */
       /* the minus is so the optimizations in addinst work */
       sempty.r[0].q0 = -p;
-			if(addinst(tl, bstartinst, &sempty))
+      if (addinst(tl, bstartinst, &sempty))
-			if(++ntl >= NLIST){
+        if (++ntl >= NLIST) {
         Overflow:
           warning(nil, "regexp list overflow\n");
           sel.r[0].q0 = -1;
@@ -762,54 +713,54 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
         }
     }
     /* Execute machine until this list is empty */
-		for(tlp = tl; inst = tlp->inst; tlp++){	/* assignment = */
+    for (tlp = tl; inst = tlp->inst; tlp++) { /* assignment = */
     Switchstmt:
-			switch(inst->type){
+      switch (inst->type) {
         default: /* regular character */
-				if(inst->type == c){
+          if (inst->type == c) {
           Addinst:
-					if(addinst(nl, inst->u1.next, &tlp->se))
+            if (addinst(nl, inst->u1.next, &tlp->se))
-					if(++nnl >= NLIST)
+              if (++nnl >= NLIST)
                 goto Overflow;
           }
           break;
         case LBRA:
-				if(inst->u.subid>=0)
+          if (inst->u.subid >= 0)
             tlp->se.r[inst->u.subid].q0 = p;
           inst = inst->u1.next;
           goto Switchstmt;
         case RBRA:
-				if(inst->u.subid >= 0)
+          if (inst->u.subid >= 0)
             tlp->se.r[inst->u.subid].q1 = p;
           inst = inst->u1.next;
           goto Switchstmt;
         case ANY:
-				if(c != '\n')
+          if (c != '\n')
             goto Addinst;
           break;
         case BOL:
-				if(c=='\n' || p==0){
+          if (c == '\n' || p == 0) {
           Step:
             inst = inst->u1.next;
             goto Switchstmt;
           }
           break;
         case EOL:
-				if(p<t->file->b.nc && textreadc(t, p)=='\n')
+          if (p < t->file->b.nc && textreadc(t, p) == '\n')
             goto Step;
           break;
         case CCLASS:
-				if(c>0 && classmatch(inst->u.class, c, 0))
+          if (c > 0 && classmatch(inst->u.class, c, 0))
             goto Addinst;
           break;
         case NCCLASS:
-				if(c>0 && classmatch(inst->u.class, c, 1))
+          if (c > 0 && classmatch(inst->u.class, c, 1))
             goto Addinst;
           break;
         case OR:
           /* evaluate right choice later */
-				if(addinst(tl, inst->u.right, &tlp->se))
+          if (addinst(tl, inst->u.right, &tlp->se))
-				if(++ntl >= NLIST)
+            if (++ntl >= NLIST)
               goto Overflow;
           /* efficiency: advance and re-evaluate */
           inst = inst->u1.left;
@@ -822,18 +773,18 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
       }
     }
   }
-    Return:
+Return:
   *rp = sel;
   return sel.r[0].q0 >= 0;
 }
 
-void
+void bnewmatch(Rangeset* sp) {
-bnewmatch(Rangeset *sp)
-{
   int i;
 
-        if(sel.r[0].q0<0 || sp->r[0].q0>sel.r[0].q1 || (sp->r[0].q0==sel.r[0].q1 && sp->r[0].q1<sel.r[0].q0))
+  if (
-                for(i = 0; i<NRange; i++){       /* note the reversal; q0<=q1 */
+    sel.r[0].q0 < 0 || sp->r[0].q0 > sel.r[0].q1 ||
+    (sp->r[0].q0 == sel.r[0].q1 && sp->r[0].q1 < sel.r[0].q0))
+    for (i = 0; i < NRange; i++) { /* note the reversal; q0<=q1 */
       sel.r[i].q0 = sp->r[i].q1;
       sel.r[i].q1 = sp->r[i].q0;
     }

scrl.c

@@ -12,77 +12,73 @@
 #include "dat.h"
 #include "fns.h"
 
-static Image *scrtmp;
+static Image* scrtmp;
 
-static
+static Rectangle scrpos(Rectangle r, uint p0, uint p1, uint tot) {
-Rectangle
-scrpos(Rectangle r, uint p0, uint p1, uint tot)
-{
   Rectangle q;
   int h;
 
   q = r;
-	h = q.max.y-q.min.y;
+  h = q.max.y - q.min.y;
-	if(tot == 0)
+  if (tot == 0)
     return q;
-	if(tot > 1024*1024){
+  if (tot > 1024 * 1024) {
-		tot>>=10;
+    tot >>= 10;
-		p0>>=10;
+    p0 >>= 10;
-		p1>>=10;
+    p1 >>= 10;
   }
-	if(p0 > 0)
+  if (p0 > 0)
-		q.min.y += h*p0/tot;
+    q.min.y += h * p0 / tot;
-	if(p1 < tot)
+  if (p1 < tot)
-		q.max.y -= h*(tot-p1)/tot;
+    q.max.y -= h * (tot - p1) / tot;
-	if(q.max.y < q.min.y+2){
+  if (q.max.y < q.min.y + 2) {
-		if(q.min.y+2 <= r.max.y)
+    if (q.min.y + 2 <= r.max.y)
-			q.max.y = q.min.y+2;
+      q.max.y = q.min.y + 2;
     else
-			q.min.y = q.max.y-2;
+      q.min.y = q.max.y - 2;
   }
   return q;
 }
 
-void
+void scrlresize(void) {
-scrlresize(void)
-{
   freeimage(scrtmp);
-	scrtmp = allocimage(display, Rect(0, 0, 32, screen->r.max.y), screen->chan, 0, DNofill);
+  scrtmp = allocimage(
-	if(scrtmp == nil)
+    display,
+    Rect(0, 0, 32, screen->r.max.y),
+    screen->chan,
+    0,
+    DNofill);
+  if (scrtmp == nil)
     error("scroll alloc");
 }
 
-void
+void textscrdraw(Text* t) {
-textscrdraw(Text *t)
-{
   Rectangle r, r1, r2;
-	Image *b;
+  Image* b;
 
-	if(t->w==nil || t!=&t->w->body)
+  if (t->w == nil || t != &t->w->body)
     return;
-	if(scrtmp == nil)
+  if (scrtmp == nil)
     scrlresize();
   r = t->scrollr;
   b = scrtmp;
   r1 = r;
   r1.min.x = 0;
   r1.max.x = Dx(r);
-	r2 = scrpos(r1, t->org, t->org+t->fr.nchars, t->file->b.nc);
+  r2 = scrpos(r1, t->org, t->org + t->fr.nchars, t->file->b.nc);
-	if(!eqrect(r2, t->lastsr)){
+  if (!eqrect(r2, t->lastsr)) {
     t->lastsr = r2;
     draw(b, r1, t->fr.cols[BORD], nil, ZP);
     draw(b, r2, t->fr.cols[BACK], nil, ZP);
-		r2.min.x = r2.max.x-1;
+    r2.min.x = r2.max.x - 1;
     draw(b, r2, t->fr.cols[BORD], nil, ZP);
     draw(t->fr.b, r, b, nil, Pt(0, r1.min.y));
-/*flushimage(display, 1); // BUG? */
+    /*flushimage(display, 1); // BUG? */
   }
 }
 
-void
+void scrsleep(uint dt) {
-scrsleep(uint dt)
+  Timer* timer;
-{
-	Timer	*timer;
   static Alt alts[3];
 
   timer = timerstart(dt);
@@ -93,8 +89,8 @@ scrsleep(uint dt)
   alts[1].v = &mousectl->m;
   alts[1].op = CHANRCV;
   alts[2].op = CHANEND;
-	for(;;)
+  for (;;)
-		switch(alt(alts)){
+    switch (alt(alts)) {
       case 0:
         timerstop(timer);
         return;
@@ -104,56 +100,54 @@ scrsleep(uint dt)
     }
 }
 
-void
+void textscroll(Text* t, int but) {
-textscroll(Text *t, int but)
-{
   uint p0, oldp0;
   Rectangle s;
   int x, y, my, h, first;
 
   s = insetrect(t->scrollr, 1);
-	h = s.max.y-s.min.y;
+  h = s.max.y - s.min.y;
-	x = (s.min.x+s.max.x)/2;
+  x = (s.min.x + s.max.x) / 2;
   oldp0 = ~0;
   first = TRUE;
-	do{
+  do {
     flushimage(display, 1);
     my = mouse->xy.y;
-		if(my < s.min.y)
+    if (my < s.min.y)
       my = s.min.y;
-		if(my >= s.max.y)
+    if (my >= s.max.y)
       my = s.max.y;
-		if(!eqpt(mouse->xy, Pt(x, my))){
+    if (!eqpt(mouse->xy, Pt(x, my))) {
       moveto(mousectl, Pt(x, my));
       readmouse(mousectl); /* absorb event generated by moveto() */
     }
-		if(but == 2){
+    if (but == 2) {
       y = my;
-			p0 = (vlong)t->file->b.nc*(y-s.min.y)/h;
+      p0 = (vlong)t->file->b.nc * (y - s.min.y) / h;
-			if(p0 >= t->q1)
+      if (p0 >= t->q1)
         p0 = textbacknl(t, p0, 2);
-			if(oldp0 != p0)
+      if (oldp0 != p0)
         textsetorigin(t, p0, FALSE);
       oldp0 = p0;
       readmouse(mousectl);
       continue;
     }
-		if(but == 1)
+    if (but == 1)
-			p0 = textbacknl(t, t->org, (my-s.min.y)/t->fr.font->height);
+      p0 = textbacknl(t, t->org, (my - s.min.y) / t->fr.font->height);
     else
-			p0 = t->org+frcharofpt(&t->fr, Pt(s.max.x, my));
+      p0 = t->org + frcharofpt(&t->fr, Pt(s.max.x, my));
-		if(oldp0 != p0)
+    if (oldp0 != p0)
       textsetorigin(t, p0, TRUE);
     oldp0 = p0;
     /* debounce */
-		if(first){
+    if (first) {
       flushimage(display, 1);
       sleep(200);
       nbrecv(mousectl->c, &mousectl->m);
       first = FALSE;
     }
     scrsleep(80);
-	}while(mouse->buttons & (1<<(but-1)));
+  } while (mouse->buttons & (1 << (but - 1)));
-	while(mouse->buttons)
+  while (mouse->buttons)
     readmouse(mousectl);
 }

time.c

@@ -13,32 +13,18 @@
 #include "fns.h"
 
 static Channel* ctimer; /* chan(Timer*)[100] */
-static Timer *timer;
+static Timer* timer;
 
-static
+static uint msec(void) { return nsec() / 1000000; }
-uint
-msec(void)
-{
-	return nsec()/1000000;
-}
 
-void
+void timerstop(Timer* t) {
-timerstop(Timer *t)
-{
   t->next = timer;
   timer = t;
 }
 
-void
+void timercancel(Timer* t) { t->cancel = TRUE; }
-timercancel(Timer *t)
-{
-	t->cancel = TRUE;
-}
 
-static
+static void timerproc(void* v) {
-void
-timerproc(void *v)
-{
   int i, nt, na, dt, del;
   Timer **t, *x;
   uint old, new;
@@ -50,68 +36,65 @@ timerproc(void *v)
   na = 0;
   nt = 0;
   old = msec();
-	for(;;){
+  for (;;) {
-		sleep(10);	/* longer sleeps here delay recv on ctimer, but 10ms should not be noticeable */
+    sleep(10); /* longer sleeps here delay recv on ctimer, but 10ms should not
+                  be noticeable */
     new = msec();
-		dt = new-old;
+    dt = new - old;
     old = new;
-		if(dt < 0)	/* timer wrapped; go around, losing a tick */
+    if (dt < 0) /* timer wrapped; go around, losing a tick */
       continue;
-		for(i=0; i<nt; i++){
+    for (i = 0; i < nt; i++) {
       x = t[i];
       x->dt -= dt;
       del = FALSE;
-			if(x->cancel){
+      if (x->cancel) {
         timerstop(x);
         del = TRUE;
-			}else if(x->dt <= 0){
+      } else if (x->dt <= 0) {
         /*
          * avoid possible deadlock if client is
          * now sending on ctimer
          */
-				if(nbsendul(x->c, 0) > 0)
+        if (nbsendul(x->c, 0) > 0)
           del = TRUE;
       }
-			if(del){
+      if (del) {
-				memmove(&t[i], &t[i+1], (nt-i-1)*sizeof t[0]);
+        memmove(&t[i], &t[i + 1], (nt - i - 1) * sizeof t[0]);
         --nt;
         --i;
       }
     }
-		if(nt == 0){
+    if (nt == 0) {
       x = recvp(ctimer);
     gotit:
-			if(nt == na){
+      if (nt == na) {
         na += 10;
-				t = realloc(t, na*sizeof(Timer*));
+        t = realloc(t, na * sizeof(Timer*));
-				if(t == nil)
+        if (t == nil)
           error("timer realloc failed");
       }
       t[nt++] = x;
       old = msec();
     }
-		if(nbrecv(ctimer, &x) > 0)
+    if (nbrecv(ctimer, &x) > 0)
       goto gotit;
   }
 }
 
-void
+void timerinit(void) {
-timerinit(void)
-{
   ctimer = chancreate(sizeof(Timer*), 100);
   chansetname(ctimer, "ctimer");
   proccreate(timerproc, nil, STACK);
 }
 
-Timer*
+Timer* timerstart(int dt) {
-timerstart(int dt)
+  Timer* t;
-{
-	Timer *t;
 
   t = timer;
-	if(t)
+  if (t)
     timer = timer->next;
-	else{
+  else {
     t = emalloc(sizeof(Timer));
     t->c = chancreate(sizeof(int), 0);
     chansetname(t->c, "tc%p", t->c);

util.c

@@ -13,11 +13,9 @@
 #include "fns.h"
 
 static Point prevmouse;
-static	Window	*mousew;
+static Window* mousew;
 
-Range
+Range range(int q0, int q1) {
-range(int q0, int q1)
-{
   Range r;
 
   r.q0 = q0;
@@ -25,9 +23,7 @@ range(int q0, int q1)
   return r;
 }
 
-Runestr
+Runestr runestr(Rune* r, uint n) {
-runestr(Rune *r, uint n)
-{
   Runestr rs;
 
   rs.r = r;
@@ -35,11 +31,9 @@ runestr(Rune *r, uint n)
   return rs;
 }
 
-void
+void cvttorunes(char* p, int n, Rune* r, int* nb, int* nr, int* nulls) {
-cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
+  uchar* q;
-{
+  Rune* s;
-	uchar *q;
-	Rune *s;
   int j, w;
 
   /*
@@ -51,80 +45,74 @@ cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
    */
   q = (uchar*)p;
   s = r;
-	for(j=0; j<n; j+=w){
+  for (j = 0; j < n; j += w) {
-		if(*q < Runeself){
+    if (*q < Runeself) {
       w = 1;
       *s = *q++;
-		}else{
+    } else {
       w = chartorune(s, (char*)q);
       q += w;
     }
-		if(*s)
+    if (*s)
       s++;
-		else if(nulls)
+    else if (nulls)
       *nulls = TRUE;
   }
-	*nb = (char*)q-p;
+  *nb = (char*)q - p;
-	*nr = s-r;
+  *nr = s - r;
 }
 
-void
+void error(char* s) {
-error(char *s)
-{
   fprint(2, "acme: %s: %r\n", s);
   threadexitsall(nil);
 }
 
-Window*
+Window* errorwin1(Rune* dir, int ndir, Rune** incl, int nincl) {
-errorwin1(Rune *dir, int ndir, Rune **incl, int nincl)
+  Window* w;
-{
+  Rune* r;
-	Window *w;
-	Rune *r;
   int i, n;
-	static Rune Lpluserrors[] = { '+', 'E', 'r', 'r', 'o', 'r', 's', 0 };
+  static Rune Lpluserrors[] = {'+', 'E', 'r', 'r', 'o', 'r', 's', 0};
 
-	r = runemalloc(ndir+8);
+  r = runemalloc(ndir + 8);
-	if((n = ndir) != 0){
+  if ((n = ndir) != 0) {
     runemove(r, dir, ndir);
     r[n++] = L'/';
   }
-	runemove(r+n, Lpluserrors, 7);
+  runemove(r + n, Lpluserrors, 7);
   n += 7;
   w = lookfile(r, n);
-	if(w == nil){
+  if (w == nil) {
-		if(row.ncol == 0)
+    if (row.ncol == 0)
-			if(rowadd(&row, nil, -1) == nil)
+      if (rowadd(&row, nil, -1) == nil)
         error("can't create column to make error window");
-		w = coladd(row.col[row.ncol-1], nil, nil, -1);
+    w = coladd(row.col[row.ncol - 1], nil, nil, -1);
     w->filemenu = FALSE;
     winsetname(w, r, n);
     xfidlog(w, "new");
   }
   free(r);
-	for(i=nincl; --i>=0; ){
+  for (i = nincl; --i >= 0;) {
     n = runestrlen(incl[i]);
     r = runemalloc(n);
     runemove(r, incl[i], n);
     winaddincl(w, r, n);
   }
-	for(i=0; i<NINDENT; i++)
+  for (i = 0; i < NINDENT; i++)
     w->indent[i] = globalindent[i];
   return w;
 }
 
 /* make new window, if necessary; return with it locked */
-Window*
+Window* errorwin(Mntdir* md, int owner) {
-errorwin(Mntdir *md, int owner)
+  Window* w;
-{
-	Window *w;
 
-	for(;;){
+  for (;;) {
-		if(md == nil)
+    if (md == nil)
       w = errorwin1(nil, 0, nil, 0);
     else
       w = errorwin1(md->dir, md->ndir, md->incl, md->nincl);
     winlock(w, owner);
-		if(w->col != nil)
+    if (w->col != nil)
       break;
     /* window was deleted too fast */
     winunlock(w);
@@ -137,37 +125,35 @@ errorwin(Mntdir *md, int owner)
  * It will be unlocked and returned window
  * will be locked in its place.
  */
-Window*
+Window* errorwinforwin(Window* w) {
-errorwinforwin(Window *w)
-{
   int i, n, nincl, owner;
-	Rune **incl;
+  Rune** incl;
   Runestr dir;
-	Text *t;
+  Text* t;
 
   t = &w->body;
   dir = dirname(t, nil, 0);
-	if(dir.nr==1 && dir.r[0]=='.'){	/* sigh */
+  if (dir.nr == 1 && dir.r[0] == '.') { /* sigh */
     free(dir.r);
     dir.r = nil;
     dir.nr = 0;
   }
   incl = nil;
   nincl = w->nincl;
-	if(nincl > 0){
+  if (nincl > 0) {
-		incl = emalloc(nincl*sizeof(Rune*));
+    incl = emalloc(nincl * sizeof(Rune*));
-		for(i=0; i<nincl; i++){
+    for (i = 0; i < nincl; i++) {
       n = runestrlen(w->incl[i]);
-			incl[i] = runemalloc(n+1);
+      incl[i] = runemalloc(n + 1);
       runemove(incl[i], w->incl[i], n);
     }
   }
   owner = w->owner;
   winunlock(w);
-	for(;;){
+  for (;;) {
     w = errorwin1(dir.r, dir.nr, incl, nincl);
     winlock(w, owner);
-		if(w->col != nil)
+    if (w->col != nil)
       break;
     /* window deleted too fast */
     winunlock(w);
@@ -177,22 +163,19 @@ errorwinforwin(Window *w)
 
 typedef struct Warning Warning;
 
-struct Warning{
+struct Warning {
-	Mntdir *md;
+  Mntdir* md;
   Buffer buf;
-	Warning *next;
+  Warning* next;
 };
 
-static Warning *warnings;
+static Warning* warnings;
 
-static
+static void addwarningtext(Mntdir* md, Rune* r, int nr) {
-void
+  Warning* warn;
-addwarningtext(Mntdir *md, Rune *r, int nr)
-{
-	Warning *warn;
 
-	for(warn = warnings; warn; warn=warn->next){
+  for (warn = warnings; warn; warn = warn->next) {
-		if(warn->md == md){
+    if (warn->md == md) {
       bufinsert(&warn->buf, warn->buf.nc, r, nr);
       return;
     }
@@ -200,7 +183,7 @@ addwarningtext(Mntdir *md, Rune *r, int nr)
   warn = emalloc(sizeof(Warning));
   warn->next = warnings;
   warn->md = md;
-	if(md)
+  if (md)
     fsysincid(md);
   warnings = warn;
   bufinsert(&warn->buf, 0, r, nr);
@@ -208,20 +191,18 @@ addwarningtext(Mntdir *md, Rune *r, int nr)
 }
 
 /* called while row is locked */
-void
+void flushwarnings(void) {
-flushwarnings(void)
-{
   Warning *warn, *next;
-	Window *w;
+  Window* w;
-	Text *t;
+  Text* t;
   int owner, nr, q0, n;
-	Rune *r;
+  Rune* r;
 
-	for(warn=warnings; warn; warn=next) {
+  for (warn = warnings; warn; warn = next) {
     w = errorwin(warn->md, 'E');
     t = &w->body;
     owner = w->owner;
-		if(owner == 0)
+    if (owner == 0)
       w->owner = 'E';
     wincommit(w, t);
     /*
@@ -234,9 +215,9 @@ flushwarnings(void)
      */
     r = fbufalloc();
     q0 = t->file->b.nc;
-		for(n = 0; n < warn->buf.nc; n += nr){
+    for (n = 0; n < warn->buf.nc; n += nr) {
       nr = warn->buf.nc - n;
-			if(nr > RBUFSIZE)
+      if (nr > RBUFSIZE)
         nr = RBUFSIZE;
       bufread(&warn->buf, n, r, nr);
       textbsinsert(t, t->file->b.nc, r, nr, TRUE, &nr);
@@ -250,117 +231,95 @@ flushwarnings(void)
     winunlock(w);
     bufclose(&warn->buf);
     next = warn->next;
-		if(warn->md)
+    if (warn->md)
       fsysdelid(warn->md);
     free(warn);
   }
   warnings = nil;
 }
 
-void
+void warning(Mntdir* md, char* s, ...) {
-warning(Mntdir *md, char *s, ...)
+  Rune* r;
-{
-	Rune *r;
   va_list arg;
 
   va_start(arg, s);
   r = runevsmprint(s, arg);
   va_end(arg);
-	if(r == nil)
+  if (r == nil)
     error("runevsmprint failed");
   addwarningtext(md, r, runestrlen(r));
   free(r);
 }
 
-int
+int runeeq(Rune* s1, uint n1, Rune* s2, uint n2) {
-runeeq(Rune *s1, uint n1, Rune *s2, uint n2)
+  if (n1 != n2)
-{
-	if(n1 != n2)
     return FALSE;
-	return memcmp(s1, s2, n1*sizeof(Rune)) == 0;
+  return memcmp(s1, s2, n1 * sizeof(Rune)) == 0;
 }
 
-uint
+uint min(uint a, uint b) {
-min(uint a, uint b)
+  if (a < b)
-{
-	if(a < b)
     return a;
   return b;
 }
 
-uint
+uint max(uint a, uint b) {
-max(uint a, uint b)
+  if (a > b)
-{
-	if(a > b)
     return a;
   return b;
 }
 
-char*
+char* runetobyte(Rune* r, int n) {
-runetobyte(Rune *r, int n)
+  char* s;
-{
-	char *s;
 
-	if(r == nil)
+  if (r == nil)
     return nil;
-	s = emalloc(n*UTFmax+1);
+  s = emalloc(n * UTFmax + 1);
   setmalloctag(s, getcallerpc(&r));
-	snprint(s, n*UTFmax+1, "%.*S", n, r);
+  snprint(s, n * UTFmax + 1, "%.*S", n, r);
   return s;
 }
 
-Rune*
+Rune* bytetorune(char* s, int* ip) {
-bytetorune(char *s, int *ip)
+  Rune* r;
-{
-	Rune *r;
   int nb, nr;
 
   nb = strlen(s);
-	r = runemalloc(nb+1);
+  r = runemalloc(nb + 1);
   cvttorunes(s, nb, r, &nb, &nr, nil);
   r[nr] = '\0';
   *ip = nr;
   return r;
 }
 
-int
+int isalnum(Rune c) {
-isalnum(Rune c)
-{
   /*
    * Hard to get absolutely right.  Use what we know about ASCII
    * and assume anything above the Latin control characters is
    * potentially an alphanumeric.
    */
-	if(c <= ' ')
+  if (c <= ' ')
     return FALSE;
-	if(0x7F<=c && c<=0xA0)
+  if (0x7F <= c && c <= 0xA0)
     return FALSE;
-	if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
+  if (utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
     return FALSE;
   return TRUE;
 }
 
-int
+int rgetc(void* v, uint n) { return ((Rune*)v)[n]; }
-rgetc(void *v, uint n)
-{
-	return ((Rune*)v)[n];
-}
 
-int
+int tgetc(void* a, uint n) {
-tgetc(void *a, uint n)
+  Text* t;
-{
-	Text *t;
 
   t = a;
-	if(n >= t->file->b.nc)
+  if (n >= t->file->b.nc)
     return 0;
   return textreadc(t, n);
 }
 
-Rune*
+Rune* skipbl(Rune* r, int n, int* np) {
-skipbl(Rune *r, int n, int *np)
+  while (n > 0 && (*r == ' ' || *r == '\t' || *r == '\n')) {
-{
-	while(n>0 && (*r==' ' || *r=='\t' || *r=='\n')){
     --n;
     r++;
   }
@@ -368,10 +327,8 @@ skipbl(Rune *r, int n, int *np)
   return r;
 }
 
-Rune*
+Rune* findbl(Rune* r, int n, int* np) {
-findbl(Rune *r, int n, int *np)
+  while (n > 0 && *r != ' ' && *r != '\t' && *r != '\n') {
-{
-	while(n>0 && *r!=' ' && *r!='\t' && *r!='\n'){
     --n;
     r++;
   }
@@ -379,20 +336,16 @@ findbl(Rune *r, int n, int *np)
   return r;
 }
 
-void
+void savemouse(Window* w) {
-savemouse(Window *w)
-{
   prevmouse = mouse->xy;
   mousew = w;
 }
 
-int
+int restoremouse(Window* w) {
-restoremouse(Window *w)
-{
   int did;
 
   did = 0;
-	if(mousew!=nil && mousew==w) {
+  if (mousew != nil && mousew == w) {
     moveto(mousectl, prevmouse);
     did = 1;
   }
@@ -400,42 +353,32 @@ restoremouse(Window *w)
   return did;
 }
 
-void
+void clearmouse() { mousew = nil; }
-clearmouse()
-{
-	mousew = nil;
-}
 
-char*
+char* estrdup(char* s) {
-estrdup(char *s)
+  char* t;
-{
-	char *t;
 
   t = strdup(s);
-	if(t == nil)
+  if (t == nil)
     error("strdup failed");
   setmalloctag(t, getcallerpc(&s));
   return t;
 }
 
-void*
+void* emalloc(uint n) {
-emalloc(uint n)
+  void* p;
-{
-	void *p;
 
   p = malloc(n);
-	if(p == nil)
+  if (p == nil)
     error("malloc failed");
   setmalloctag(p, getcallerpc(&n));
   memset(p, 0, n);
   return p;
 }
 
-void*
+void* erealloc(void* p, uint n) {
-erealloc(void *p, uint n)
-{
   p = realloc(p, n);
-	if(p == nil)
+  if (p == nil)
     error("realloc failed");
   setmalloctag(p, getcallerpc(&n));
   return p;
@@ -444,53 +387,53 @@ erealloc(void *p, uint n)
 /*
  * Heuristic city.
  */
-Window*
+Window* makenewwindow(Text* t) {
-makenewwindow(Text *t)
+  Column* c;
-{
-	Column *c;
   Window *w, *bigw, *emptyw;
-	Text *emptyb;
+  Text* emptyb;
   int i, y, el;
 
-	if(activecol)
+  if (activecol)
     c = activecol;
-	else if(seltext && seltext->col)
+  else if (seltext && seltext->col)
     c = seltext->col;
-	else if(t && t->col)
+  else if (t && t->col)
     c = t->col;
-	else{
+  else {
-		if(row.ncol==0 && rowadd(&row, nil, -1)==nil)
+    if (row.ncol == 0 && rowadd(&row, nil, -1) == nil)
       error("can't make column");
-		c = row.col[row.ncol-1];
+    c = row.col[row.ncol - 1];
   }
   activecol = c;
-	if(t==nil || t->w==nil || c->nw==0)
+  if (t == nil || t->w == nil || c->nw == 0)
     return coladd(c, nil, nil, -1);
 
   /* find biggest window and biggest blank spot */
   emptyw = c->w[0];
   bigw = emptyw;
-	for(i=1; i<c->nw; i++){
+  for (i = 1; i < c->nw; i++) {
     w = c->w[i];
     /* use >= to choose one near bottom of screen */
-		if(w->body.fr.maxlines >= bigw->body.fr.maxlines)
+    if (w->body.fr.maxlines >= bigw->body.fr.maxlines)
       bigw = w;
-		if(w->body.fr.maxlines-w->body.fr.nlines >= emptyw->body.fr.maxlines-emptyw->body.fr.nlines)
+    if (
+      w->body.fr.maxlines - w->body.fr.nlines >=
+      emptyw->body.fr.maxlines - emptyw->body.fr.nlines)
       emptyw = w;
   }
   emptyb = &emptyw->body;
-	el = emptyb->fr.maxlines-emptyb->fr.nlines;
+  el = emptyb->fr.maxlines - emptyb->fr.nlines;
   /* if empty space is big, use it */
-	if(el>15 || (el>3 && el>(bigw->body.fr.maxlines-1)/2))
+  if (el > 15 || (el > 3 && el > (bigw->body.fr.maxlines - 1) / 2))
-		y = emptyb->fr.r.min.y+emptyb->fr.nlines*font->height;
+    y = emptyb->fr.r.min.y + emptyb->fr.nlines * font->height;
-	else{
+  else {
     /* if this window is in column and isn't much smaller, split it */
-		if(t->col==c && Dy(t->w->r)>2*Dy(bigw->r)/3)
+    if (t->col == c && Dy(t->w->r) > 2 * Dy(bigw->r) / 3)
       bigw = t->w;
-		y = (bigw->r.min.y + bigw->r.max.y)/2;
+    y = (bigw->r.min.y + bigw->r.max.y) / 2;
   }
   w = coladd(c, nil, nil, y);
-	if(w->body.fr.maxlines < 2)
+  if (w->body.fr.maxlines < 2)
     colgrow(w->col, w, 1);
   return w;
 }

wind.c

@@ -14,13 +14,11 @@
 
 int winid;
 
-void
+void wininit(Window* w, Window* clone, Rectangle r) {
-wininit(Window *w, Window *clone, Rectangle r)
-{
   Rectangle r1, br;
-	File *f;
+  File* f;
-	Reffont *rf;
+  Reffont* rf;
-	Rune *rp;
+  Rune* rp;
   int nc, i;
 
   w->tag.w = w;
@@ -29,7 +27,7 @@ wininit(Window *w, Window *clone, Rectangle r)
   w->body.w = w;
   w->id = ++winid;
   incref(&w->ref);
-	if(globalincref)
+  if (globalincref)
     incref(&w->ref);
   w->ctlfid = ~0;
   w->utflastqid = -1;
@@ -37,14 +35,14 @@ wininit(Window *w, Window *clone, Rectangle r)
 
   w->tagtop = r;
   w->tagtop.max.y = r.min.y + font->height;
-	r1.max.y = r1.min.y + w->taglines*font->height;
+  r1.max.y = r1.min.y + w->taglines * font->height;
 
   incref(&reffont.ref);
   f = fileaddtext(nil, &w->tag);
   textinit(&w->tag, f, r1, &reffont, tagcols);
   w->tag.what = Tag;
   /* tag is a copy of the contents, not a tracked image */
-	if(clone){
+  if (clone) {
     textdelete(&w->tag, 0, w->tag.file->b.nc, TRUE);
     nc = clone->tag.file->b.nc;
     rp = runemalloc(nc);
@@ -55,22 +53,22 @@ wininit(Window *w, Window *clone, Rectangle r)
     textsetselect(&w->tag, nc, nc);
   }
   r1 = r;
-	r1.min.y += w->taglines*font->height + 1;
+  r1.min.y += w->taglines * font->height + 1;
-	if(r1.max.y < r1.min.y)
+  if (r1.max.y < r1.min.y)
     r1.max.y = r1.min.y;
   f = nil;
-	if(clone){
+  if (clone) {
     f = clone->body.file;
     w->body.org = clone->body.org;
     w->isscratch = clone->isscratch;
     rf = rfget(FALSE, FALSE, FALSE, clone->body.reffont->f->name);
-	}else
+  } else
     rf = rfget(FALSE, FALSE, FALSE, nil);
   f = fileaddtext(f, &w->body);
   w->body.what = Body;
   textinit(&w->body, f, r1, rf, textcols);
   r1.min.y -= 1;
-	r1.max.y = r1.min.y+1;
+  r1.max.y = r1.min.y + 1;
   draw(screen, r1, tagcols[BORD], nil, ZP);
   textscrdraw(&w->body);
   w->r = r;
@@ -80,11 +78,11 @@ wininit(Window *w, Window *clone, Rectangle r)
   draw(screen, br, button, nil, button->r.min);
   w->filemenu = TRUE;
   w->maxlines = w->body.fr.maxlines;
-	for(i=0; i<NINDENT; i++)
+  for (i = 0; i < NINDENT; i++)
     w->indent[i] = globalindent[i];
-	if(clone){
+  if (clone) {
     w->dirty = clone->dirty;
-		for(i=0; i<NINDENT; i++)
+    for (i = 0; i < NINDENT; i++)
       w->indent[i] = clone->indent[i];
     textsetselect(&w->body, clone->body.q0, clone->body.q1);
     winsettag(w);
@@ -94,14 +92,12 @@ wininit(Window *w, Window *clone, Rectangle r)
 /*
  * Draw the appropriate button.
  */
-void
+void windrawbutton(Window* w) {
-windrawbutton(Window *w)
+  Image* b;
-{
-	Image *b;
   Rectangle br;
 
   b = button;
-	if(!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
+  if (!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
     b = modbutton;
   br.min = w->tag.scrollr.min;
   br.max.x = br.min.x + Dx(b->r);
@@ -109,46 +105,42 @@ windrawbutton(Window *w)
   draw(screen, br, b, nil, b->r.min);
 }
 
-int
+int delrunepos(Window* w) {
-delrunepos(Window *w)
-{
   int n;
   Rune rune;
 
-	for(n=0; n<w->tag.file->b.nc; n++) {
+  for (n = 0; n < w->tag.file->b.nc; n++) {
     bufread(&w->tag.file->b, n, &rune, 1);
-		if(rune == ' ')
+    if (rune == ' ')
       break;
   }
   n += 2;
-	if(n >= w->tag.file->b.nc)
+  if (n >= w->tag.file->b.nc)
     return -1;
   return n;
 }
 
-void
+void movetodel(Window* w) {
-movetodel(Window *w)
-{
   int n;
 
   n = delrunepos(w);
-	if(n < 0)
+  if (n < 0)
     return;
-	moveto(mousectl, addpt(frptofchar(&w->tag.fr, n), Pt(4, w->tag.fr.font->height-4)));
+  moveto(
+    mousectl,
+    addpt(frptofchar(&w->tag.fr, n), Pt(4, w->tag.fr.font->height - 4)));
 }
 
 /*
  * Compute number of tag lines required
  * to display entire tag text.
  */
-int
+int wintaglines(Window* w, Rectangle r) {
-wintaglines(Window *w, Rectangle r)
-{
   int n;
   Rune rune;
   Point p;
 
-	if(!w->tagexpand && !w->showdel)
+  if (!w->tagexpand && !w->showdel)
     return 1;
   w->showdel = FALSE;
   w->tag.fr.noredraw = 1;
@@ -156,34 +148,32 @@ wintaglines(Window *w, Rectangle r)
   w->tag.fr.noredraw = 0;
   w->tagsafe = FALSE;
 
-	if(!w->tagexpand) {
+  if (!w->tagexpand) {
     /* use just as many lines as needed to show the Del */
     n = delrunepos(w);
-		if(n < 0)
+    if (n < 0)
       return 1;
     p = subpt(frptofchar(&w->tag.fr, n), w->tag.fr.r.min);
     return 1 + p.y / w->tag.fr.font->height;
   }
 
   /* can't use more than we have */
-	if(w->tag.fr.nlines >= w->tag.fr.maxlines)
+  if (w->tag.fr.nlines >= w->tag.fr.maxlines)
     return w->tag.fr.maxlines;
 
   /* if tag ends with \n, include empty line at end for typing */
   n = w->tag.fr.nlines;
-	if(w->tag.file->b.nc > 0){
+  if (w->tag.file->b.nc > 0) {
-		bufread(&w->tag.file->b, w->tag.file->b.nc-1, &rune, 1);
+    bufread(&w->tag.file->b, w->tag.file->b.nc - 1, &rune, 1);
-		if(rune == '\n')
+    if (rune == '\n')
       n++;
   }
-	if(n == 0)
+  if (n == 0)
     n = 1;
   return n;
 }
 
-int
+int winresize(Window* w, Rectangle r, int safe, int keepextra) {
-winresize(Window *w, Rectangle r, int safe, int keepextra)
-{
   int oy, y, mouseintag, mouseinbody;
   Point p;
   Rectangle r1;
@@ -193,36 +183,36 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
 
   /* tagtop is first line of tag */
   w->tagtop = r;
-	w->tagtop.max.y = r.min.y+font->height;
+  w->tagtop.max.y = r.min.y + font->height;
 
   r1 = r;
-	r1.max.y = min(r.max.y, r1.min.y + w->taglines*font->height);
+  r1.max.y = min(r.max.y, r1.min.y + w->taglines * font->height);
 
   /* If needed, recompute number of lines in tag. */
-	if(!safe || !w->tagsafe || !eqrect(w->tag.all, r1)){
+  if (!safe || !w->tagsafe || !eqrect(w->tag.all, r1)) {
     w->taglines = wintaglines(w, r);
-		r1.max.y = min(r.max.y, r1.min.y + w->taglines*font->height);
+    r1.max.y = min(r.max.y, r1.min.y + w->taglines * font->height);
   }
 
   /* If needed, resize & redraw tag. */
   y = r1.max.y;
-	if(!safe || !w->tagsafe || !eqrect(w->tag.all, r1)){
+  if (!safe || !w->tagsafe || !eqrect(w->tag.all, r1)) {
     textresize(&w->tag, r1, TRUE);
     y = w->tag.fr.r.max.y;
     windrawbutton(w);
     w->tagsafe = TRUE;
 
     /* If mouse is in tag, pull up as tag closes. */
-		if(mouseintag && !ptinrect(mouse->xy, w->tag.all)){
+    if (mouseintag && !ptinrect(mouse->xy, w->tag.all)) {
       p = mouse->xy;
-			p.y = w->tag.all.max.y-3;
+      p.y = w->tag.all.max.y - 3;
       moveto(mousectl, p);
     }
 
     /* If mouse is in body, push down as tag expands. */
-		if(mouseinbody && ptinrect(mouse->xy, w->tag.all)){
+    if (mouseinbody && ptinrect(mouse->xy, w->tag.all)) {
       p = mouse->xy;
-			p.y = w->tag.all.max.y+3;
+      p.y = w->tag.all.max.y + 3;
       moveto(mousectl, p);
     }
   }
@@ -230,16 +220,16 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
   /* If needed, resize & redraw body. */
   r1 = r;
   r1.min.y = y;
-	if(!safe || !eqrect(w->body.all, r1)){
+  if (!safe || !eqrect(w->body.all, r1)) {
     oy = y;
-		if(y+1+w->body.fr.font->height <= r.max.y){	/* room for one line */
+    if (y + 1 + w->body.fr.font->height <= r.max.y) { /* room for one line */
       r1.min.y = y;
-			r1.max.y = y+1;
+      r1.max.y = y + 1;
       draw(screen, r1, tagcols[BORD], nil, ZP);
       y++;
       r1.min.y = min(y, r.max.y);
       r1.max.y = r.max.y;
-		}else{
+    } else {
       r1.min.y = y;
       r1.max.y = y;
     }
@@ -253,30 +243,24 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
   return w->r.max.y;
 }
 
-void
+void winlock1(Window* w, int owner) {
-winlock1(Window *w, int owner)
-{
   incref(&w->ref);
   qlock(&w->lk);
   w->owner = owner;
 }
 
-void
+void winlock(Window* w, int owner) {
-winlock(Window *w, int owner)
-{
   int i;
-	File *f;
+  File* f;
 
   f = w->body.file;
-	for(i=0; i<f->ntext; i++)
+  for (i = 0; i < f->ntext; i++)
     winlock1(f->text[i]->w, owner);
 }
 
-void
+void winunlock(Window* w) {
-winunlock(Window *w)
-{
   int i;
-	File *f;
+  File* f;
 
   /*
    * subtle: loop runs backwards to avoid tripping over
@@ -284,7 +268,7 @@ winunlock(Window *w)
    * on the last iteration of the loop.
    */
   f = w->body.file;
-	for(i=f->ntext-1; i>=0; i--){
+  for (i = f->ntext - 1; i >= 0; i--) {
     w = f->text[i]->w;
     w->owner = 0;
     qunlock(&w->lk);
@@ -292,21 +276,18 @@ winunlock(Window *w)
   }
 }
 
-void
+void winmousebut(Window* w) {
-winmousebut(Window *w)
+  moveto(
-{
+    mousectl,
-	moveto(mousectl, addpt(w->tag.scrollr.min,
+    addpt(w->tag.scrollr.min, divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
-		divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
 }
 
-void
+void windirfree(Window* w) {
-windirfree(Window *w)
-{
   int i;
-	Dirlist *dl;
+  Dirlist* dl;
 
-	if(w->isdir){
+  if (w->isdir) {
-		for(i=0; i<w->ndl; i++){
+    for (i = 0; i < w->ndl; i++) {
       dl = w->dlp[i];
       free(dl->r);
       free(dl);
@@ -317,19 +298,17 @@ windirfree(Window *w)
   w->ndl = 0;
 }
 
-void
+void winclose(Window* w) {
-winclose(Window *w)
-{
   int i;
 
-	if(decref(&w->ref) == 0){
+  if (decref(&w->ref) == 0) {
     xfidlog(w, "del");
     windirfree(w);
     textclose(&w->tag);
     textclose(&w->body);
-		if(activewin == w)
+    if (activewin == w)
       activewin = nil;
-		for(i=0; i<w->nincl; i++)
+    for (i = 0; i < w->nincl; i++)
       free(w->incl[i]);
     free(w->incl);
     free(w->events);
@@ -337,13 +316,11 @@ winclose(Window *w)
   }
 }
 
-void
+void windelete(Window* w) {
-windelete(Window *w)
+  Xfid* x;
-{
-	Xfid *x;
 
   x = w->eventx;
-	if(x){
+  if (x) {
     w->nevents = 0;
     free(w->events);
     w->events = nil;
@@ -352,164 +329,183 @@ windelete(Window *w)
   }
 }
 
-void
+void winundo(Window* w, int isundo) {
-winundo(Window *w, int isundo)
+  Text* body;
-{
-	Text *body;
   int i;
-	File *f;
+  File* f;
-	Window *v;
+  Window* v;
 
   w->utflastqid = -1;
   body = &w->body;
   fileundo(body->file, isundo, &body->q0, &body->q1);
   textshow(body, body->q0, body->q1, 1);
   f = body->file;
-	for(i=0; i<f->ntext; i++){
+  for (i = 0; i < f->ntext; i++) {
     v = f->text[i]->w;
     v->dirty = (f->seq != v->putseq);
-		if(v != w){
+    if (v != w) {
-			v->body.q0 = v->body.fr.p0+v->body.org;
+      v->body.q0 = v->body.fr.p0 + v->body.org;
-			v->body.q1 = v->body.fr.p1+v->body.org;
+      v->body.q1 = v->body.fr.p1 + v->body.org;
     }
   }
   winsettag(w);
 }
 
-void
+void winsetname(Window* w, Rune* name, int n) {
-winsetname(Window *w, Rune *name, int n)
+  Text* t;
-{
+  Window* v;
-	Text *t;
-	Window *v;
   int i;
-	static Rune Lslashguide[] = { '/', 'g', 'u', 'i', 'd', 'e', 0 };
+  static Rune Lslashguide[] = {'/', 'g', 'u', 'i', 'd', 'e', 0};
-	static Rune Lpluserrors[] = { '+', 'E', 'r', 'r', 'o', 'r', 's', 0 };
+  static Rune Lpluserrors[] = {'+', 'E', 'r', 'r', 'o', 'r', 's', 0};
 
   t = &w->body;
-	if(runeeq(t->file->name, t->file->nname, name, n) == TRUE)
+  if (runeeq(t->file->name, t->file->nname, name, n) == TRUE)
     return;
   w->isscratch = FALSE;
-	if(n>=6 && runeeq(Lslashguide, 6, name+(n-6), 6))
+  if (n >= 6 && runeeq(Lslashguide, 6, name + (n - 6), 6))
     w->isscratch = TRUE;
-	else if(n>=7 && runeeq(Lpluserrors, 7, name+(n-7), 7))
+  else if (n >= 7 && runeeq(Lpluserrors, 7, name + (n - 7), 7))
     w->isscratch = TRUE;
   filesetname(t->file, name, n);
-	for(i=0; i<t->file->ntext; i++){
+  for (i = 0; i < t->file->ntext; i++) {
     v = t->file->text[i]->w;
     winsettag(v);
     v->isscratch = w->isscratch;
   }
 }
 
-void
+void wintype(Window* w, Text* t, Rune r) {
-wintype(Window *w, Text *t, Rune r)
-{
   int i;
 
   texttype(t, r);
-	if(t->what == Body)
+  if (t->what == Body)
-		for(i=0; i<t->file->ntext; i++)
+    for (i = 0; i < t->file->ntext; i++)
       textscrdraw(t->file->text[i]);
   winsettag(w);
 }
 
-void
+void wincleartag(Window* w) {
-wincleartag(Window *w)
-{
   int i, n;
-	Rune *r;
+  Rune* r;
 
   /* w must be committed */
   n = w->tag.file->b.nc;
-	r = runemalloc(n);
+  r = parsetag(w, &i);
-	bufread(&w->tag.file->b, 0, r, n);
+  for (; i < n; i++)
-	for(i=0; i<n; i++)
+    if (r[i] == '|')
-		if(r[i]==' ' || r[i]=='\t')
       break;
-	for(; i<n; i++)
+  if (i == n)
-		if(r[i] == '|')
-			break;
-	if(i == n)
     return;
   i++;
   textdelete(&w->tag, i, n, TRUE);
   free(r);
   w->tag.file->mod = FALSE;
-	if(w->tag.q0 > i)
+  if (w->tag.q0 > i)
     w->tag.q0 = i;
-	if(w->tag.q1 > i)
+  if (w->tag.q1 > i)
     w->tag.q1 = i;
   textsetselect(&w->tag, w->tag.q0, w->tag.q1);
 }
 
-void
+Rune* parsetag(Window* w, int* len) {
-winsettag1(Window *w)
+  static Rune Ldelsnarf[] =
-{
+    {' ', 'D', 'e', 'l', ' ', 'S', 'n', 'a', 'r', 'f', 0};
-	int i, j, k, n, bar, dirty, resize;
+  static Rune Lspacepipe[] = {' ', '|', 0};
-	Rune *new, *old, *r;
+  static Rune Ltabpipe[] = {' ', '|', 0};
-	uint q0, q1;
+  int i;
-	static Rune Ldelsnarf[] = { ' ', 'D', 'e', 'l', ' ',
+  Rune *r, *p, *pipe;
-		'S', 'n', 'a', 'r', 'f', 0 };
-	static Rune Lundo[] = { ' ', 'U', 'n', 'd', 'o', 0 };
-	static Rune Lredo[] = { ' ', 'R', 'e', 'd', 'o', 0 };
-	static Rune Lget[] = { ' ', 'G', 'e', 't', 0 };
-	static Rune Lput[] = { ' ', 'P', 'u', 't', 0 };
-	static Rune Llook[] = { ' ', 'L', 'o', 'o', 'k', ' ', 0 };
-	static Rune Lpipe[] = { ' ', '|', 0 };
 
-	/* there are races that get us here with stuff in the tag cache, so we take extra care to sync it */
+  r = runemalloc(w->tag.file->b.nc + 1);
-	if(w->tag.ncache!=0 || w->tag.file->mod)
+  bufread(&w->tag.file->b, 0, r, w->tag.file->b.nc);
-		wincommit(w, &w->tag);	/* check file name; also guarantees we can modify tag contents */
+  r[w->tag.file->b.nc] = '\0';
-	old = runemalloc(w->tag.file->b.nc+1);
+
-	bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
+  for (i = 0; i < w->tag.file->b.nc; i++)
-	old[w->tag.file->b.nc] = '\0';
+    if (r[i] == ' ' || r[i] == '\t')
-	for(i=0; i<w->tag.file->b.nc; i++)
-		if(old[i]==' ' || old[i]=='\t')
       break;
-	if(runeeq(old, i, w->body.file->name, w->body.file->nname) == FALSE){
+
+  /*
+   * " |" or "\t|" ends left half of tag
+   * If we find " Del Snarf" in the left half of the tag
+   * (before the pipe), that ends the file name.
+   */
+  pipe = runestrstr(r, Lspacepipe);
+  if ((p = runestrstr(r, Ltabpipe)) != nil && (pipe == nil || p < pipe))
+    pipe = p;
+  if ((p = runestrstr(r, Ldelsnarf)) != nil && (pipe == nil || p < pipe))
+    i = p - r;
+  else {
+    for (i = 0; i < w->tag.file->b.nc; i++)
+      if (r[i] == ' ' || r[i] == '\t')
+        break;
+  }
+  *len = i;
+  return r;
+}
+
+void winsettag1(Window* w) {
+  int i, j, k, n, bar, dirty, resize;
+  Rune* new, *old, *r;
+  uint q0, q1;
+  static Rune Ldelsnarf[] =
+    {' ', 'D', 'e', 'l', ' ', 'S', 'n', 'a', 'r', 'f', 0};
+  static Rune Lundo[] = {' ', 'U', 'n', 'd', 'o', 0};
+  static Rune Lredo[] = {' ', 'R', 'e', 'd', 'o', 0};
+  static Rune Lget[] = {' ', 'G', 'e', 't', 0};
+  static Rune Lput[] = {' ', 'P', 'u', 't', 0};
+  static Rune Llook[] = {' ', 'L', 'o', 'o', 'k', ' ', 0};
+  static Rune Lpipe[] = {' ', '|', 0};
+
+  /* there are races that get us here with stuff in the tag cache, so we take
+   * extra care to sync it */
+  if (w->tag.ncache != 0 || w->tag.file->mod)
+    wincommit(w, &w->tag); /* check file name; also guarantees we can modify tag
+                              contents */
+  old = parsetag(w, &i);
+  if (runeeq(old, i, w->body.file->name, w->body.file->nname) == FALSE) {
     textdelete(&w->tag, 0, i, TRUE);
     textinsert(&w->tag, 0, w->body.file->name, w->body.file->nname, TRUE);
     free(old);
-		old = runemalloc(w->tag.file->b.nc+1);
+    old = runemalloc(w->tag.file->b.nc + 1);
     bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
     old[w->tag.file->b.nc] = '\0';
   }
 
   /* compute the text for the whole tag, replacing current only if it differs */
-	new = runemalloc(w->body.file->nname+100);
+  new = runemalloc(w->body.file->nname + 100);
   i = 0;
-	runemove(new+i, w->body.file->name, w->body.file->nname);
+  runemove(new + i, w->body.file->name, w->body.file->nname);
   i += w->body.file->nname;
-	runemove(new+i, Ldelsnarf, 10);
+  runemove(new + i, Ldelsnarf, 10);
   i += 10;
-	if(w->filemenu){
+  if (w->filemenu) {
-		if(w->body.needundo || w->body.file->delta.nc>0 || w->body.ncache){
+    if (w->body.needundo || w->body.file->delta.nc > 0 || w->body.ncache) {
-			runemove(new+i, Lundo, 5);
+      runemove(new + i, Lundo, 5);
       i += 5;
     }
-		if(w->body.file->epsilon.nc > 0){
+    if (w->body.file->epsilon.nc > 0) {
-			runemove(new+i, Lredo, 5);
+      runemove(new + i, Lredo, 5);
       i += 5;
     }
-		dirty = w->body.file->nname && (w->body.ncache || w->body.file->seq!=w->putseq);
+    dirty =
-		if(!w->isdir && dirty){
+      w->body.file->nname && (w->body.ncache || w->body.file->seq != w->putseq);
-			runemove(new+i, Lput, 4);
+    if (!w->isdir && dirty) {
+      runemove(new + i, Lput, 4);
       i += 4;
     }
   }
-	if(w->isdir){
+  if (w->isdir) {
-		runemove(new+i, Lget, 4);
+    runemove(new + i, Lget, 4);
     i += 4;
   }
-	runemove(new+i, Lpipe, 2);
+  runemove(new + i, Lpipe, 2);
   i += 2;
   r = runestrchr(old, '|');
-	if(r)
+  if (r)
-		k = r-old+1;
+    k = r - old + 1;
-	else{
+  else {
     k = w->tag.file->b.nc;
-		if(w->body.file->seq == 0){
+    if (w->body.file->seq == 0) {
-			runemove(new+i, Llook, 6);
+      runemove(new + i, Llook, 6);
       i += 6;
     }
   }
@@ -517,80 +513,72 @@ winsettag1(Window *w)
 
   /* replace tag if the new one is different */
   resize = 0;
-	if(runeeq(new, i, old, k) == FALSE){
+  if (runeeq(new, i, old, k) == FALSE) {
     resize = 1;
     n = k;
-		if(n > i)
+    if (n > i)
       n = i;
-		for(j=0; j<n; j++)
+    for (j = 0; j < n; j++)
-			if(old[j] != new[j])
+      if (old[j] != new[j])
         break;
     q0 = w->tag.q0;
     q1 = w->tag.q1;
     textdelete(&w->tag, j, k, TRUE);
-		textinsert(&w->tag, j, new+j, i-j, TRUE);
+    textinsert(&w->tag, j, new + j, i - j, TRUE);
     /* try to preserve user selection */
     r = runestrchr(old, '|');
-		if(r){
+    if (r) {
-			bar = r-old;
+      bar = r - old;
-			if(q0 > bar){
+      if (q0 > bar) {
-				bar = (runestrchr(new, '|')-new)-bar;
+        bar = (runestrchr(new, '|') - new) - bar;
-				w->tag.q0 = q0+bar;
+        w->tag.q0 = q0 + bar;
-				w->tag.q1 = q1+bar;
+        w->tag.q1 = q1 + bar;
       }
     }
   }
   free(old);
   free(new);
   w->tag.file->mod = FALSE;
-	n = w->tag.file->b.nc+w->tag.ncache;
+  n = w->tag.file->b.nc + w->tag.ncache;
-	if(w->tag.q0 > n)
+  if (w->tag.q0 > n)
     w->tag.q0 = n;
-	if(w->tag.q1 > n)
+  if (w->tag.q1 > n)
     w->tag.q1 = n;
   textsetselect(&w->tag, w->tag.q0, w->tag.q1);
   windrawbutton(w);
-	if(resize){
+  if (resize) {
     w->tagsafe = 0;
     winresize(w, w->r, TRUE, TRUE);
   }
 }
 
-void
+void winsettag(Window* w) {
-winsettag(Window *w)
-{
   int i;
-	File *f;
+  File* f;
-	Window *v;
+  Window* v;
 
   f = w->body.file;
-	for(i=0; i<f->ntext; i++){
+  for (i = 0; i < f->ntext; i++) {
     v = f->text[i]->w;
-		if(v->col->safe || v->body.fr.maxlines>0)
+    if (v->col->safe || v->body.fr.maxlines > 0)
       winsettag1(v);
   }
 }
 
-void
+void wincommit(Window* w, Text* t) {
-wincommit(Window *w, Text *t)
+  Rune* r;
-{
-	Rune *r;
   int i;
-	File *f;
+  File* f;
 
   textcommit(t, TRUE);
   f = t->file;
-	if(f->ntext > 1)
+  if (f->ntext > 1)
-		for(i=0; i<f->ntext; i++)
+    for (i = 0; i < f->ntext; i++)
       textcommit(f->text[i], FALSE); /* no-op for t */
-	if(t->what == Body)
+  if (t->what == Body)
     return;
-	r = runemalloc(w->tag.file->b.nc);
+  r = parsetag(w, &i);
-	bufread(&w->tag.file->b, 0, r, w->tag.file->b.nc);
+  if (runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE) {
-	for(i=0; i<w->tag.file->b.nc; i++)
-		if(r[i]==' ' || r[i]=='\t')
-			break;
-	if(runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE){
     seq++;
     filemark(w->body.file);
     w->body.file->mod = TRUE;
@@ -601,17 +589,15 @@ wincommit(Window *w, Text *t)
   free(r);
 }
 
-void
+void winaddincl(Window* w, Rune* r, int n) {
-winaddincl(Window *w, Rune *r, int n)
+  char* a;
-{
+  Dir* d;
-	char *a;
-	Dir *d;
   Runestr rs;
 
   a = runetobyte(r, n);
   d = dirstat(a);
-	if(d == nil){
+  if (d == nil) {
-		if(a[0] == '/')
+    if (a[0] == '/')
       goto Rescue;
     rs = dirname(&w->body, r, n);
     r = rs.r;
@@ -619,13 +605,13 @@ winaddincl(Window *w, Rune *r, int n)
     free(a);
     a = runetobyte(r, n);
     d = dirstat(a);
-		if(d == nil)
+    if (d == nil)
       goto Rescue;
-		r = runerealloc(r, n+1);
+    r = runerealloc(r, n + 1);
     r[n] = 0;
   }
   free(a);
-	if((d->qid.type&QTDIR) == 0){
+  if ((d->qid.type & QTDIR) == 0) {
     free(d);
     warning(nil, "%s: not a directory\n", a);
     free(r);
@@ -633,9 +619,9 @@ winaddincl(Window *w, Rune *r, int n)
   }
   free(d);
   w->nincl++;
-	w->incl = realloc(w->incl, w->nincl*sizeof(Rune*));
+  w->incl = realloc(w->incl, w->nincl * sizeof(Rune*));
-	memmove(w->incl+1, w->incl, (w->nincl-1)*sizeof(Rune*));
+  memmove(w->incl + 1, w->incl, (w->nincl - 1) * sizeof(Rune*));
-	w->incl[0] = runemalloc(n+1);
+  w->incl[0] = runemalloc(n + 1);
   runemove(w->incl[0], r, n);
   free(r);
   return;
@@ -647,18 +633,17 @@ Rescue:
   return;
 }
 
-int
+int winclean(Window* w, int conservative) {
-winclean(Window *w, int conservative)
+  if (w->isscratch || w->isdir) /* don't whine if it's a guide file, error
-{
+                                   window, etc. */
-	if(w->isscratch || w->isdir)	/* don't whine if it's a guide file, error window, etc. */
     return TRUE;
-	if(!conservative && w->nopen[QWevent]>0)
+  if (!conservative && w->nopen[QWevent] > 0)
     return TRUE;
-	if(w->dirty){
+  if (w->dirty) {
-		if(w->body.file->nname)
+    if (w->body.file->nname)
       warning(nil, "%.*S modified\n", w->body.file->nname, w->body.file->name);
-		else{
+    else {
-			if(w->body.file->b.nc < 100)	/* don't whine if it's too small */
+      if (w->body.file->b.nc < 100) /* don't whine if it's too small */
         return TRUE;
       warning(nil, "unnamed file modified\n");
     }
@@ -668,42 +653,48 @@ winclean(Window *w, int conservative)
   return TRUE;
 }
 
-char*
+char* winctlprint(Window* w, char* buf, int fonts) {
-winctlprint(Window *w, char *buf, int fonts)
+  sprint(
-{
+    buf,
-	sprint(buf, "%11d %11d %11d %11d %11d ", w->id, w->tag.file->b.nc,
+    "%11d %11d %11d %11d %11d ",
-		w->body.file->b.nc, w->isdir, w->dirty);
+    w->id,
-	if(fonts)
+    w->tag.file->b.nc,
-		return smprint("%s%11d %q %11d ", buf, Dx(w->body.fr.r),
+    w->body.file->b.nc,
-			w->body.reffont->f->name, w->body.fr.maxtab);
+    w->isdir,
+    w->dirty);
+  if (fonts)
+    return smprint(
+      "%s%11d %q %11d ",
+      buf,
+      Dx(w->body.fr.r),
+      w->body.reffont->f->name,
+      w->body.fr.maxtab);
   return buf;
 }
 
-void
+void winevent(Window* w, char* fmt, ...) {
-winevent(Window *w, char *fmt, ...)
-{
   int n;
-	char *b;
+  char* b;
-	Xfid *x;
+  Xfid* x;
   va_list arg;
 
-	if(w->nopen[QWevent] == 0)
+  if (w->nopen[QWevent] == 0)
     return;
-	if(w->owner == 0)
+  if (w->owner == 0)
     error("no window owner");
   va_start(arg, fmt);
   b = vsmprint(fmt, arg);
   va_end(arg);
-	if(b == nil)
+  if (b == nil)
     error("vsmprint failed");
   n = strlen(b);
-	w->events = erealloc(w->events, w->nevents+1+n);
+  w->events = erealloc(w->events, w->nevents + 1 + n);
   w->events[w->nevents++] = w->owner;
-	memmove(w->events+w->nevents, b, n);
+  memmove(w->events + w->nevents, b, n);
   free(b);
   w->nevents += n;
   x = w->eventx;
-	if(x){
+  if (x) {
     w->eventx = nil;
     sendp(x->c, nil);
   }