diff --git a/src/cmd/du.c b/src/cmd/du.c
index f3002d5..d4a94db 100644
--- a/src/cmd/du.c
+++ b/src/cmd/du.c
@@ -2,29 +2,29 @@
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
+#include <unistd.h>
+#include <sys/dir.h>
 #include <sys/param.h>
 #include <sys/stat.h>
-#include <sys/dir.h>
+#include <sys/wait.h>
 
-char    path[BUFSIZ], name[BUFSIZ];
+char path[BUFSIZ], name[BUFSIZ];
 int aflg;
 int sflg;
-char    *dot = ".";
+char *dot = ".";
 
-#define ML  1000
+#define ML 1000
 struct {
     int dev;
-    ino_t   ino;
+    ino_t ino;
 } ml[ML];
 int mlx;
 
-long    descend();
+long descend();
 
-#define kb(n)   (howmany(n * DEV_BSIZE, 1024))
+#define kb(n) (howmany(n * DEV_BSIZE, 1024))
 
-main(argc, argv)
-    int argc;
-    char **argv;
+int main(int argc, char **argv)
 {
     long blocks = 0;
     register char *np;
@@ -57,9 +57,9 @@ again:
                 wait((int *)0);
         }
         if (argc == 1 || pid == 0) {
-            (void) strcpy(path, *argv);
-            (void) strcpy(name, *argv);
-            if (np = rindex(name, '/')) {
+            (void)strcpy(path, *argv);
+            (void)strcpy(name, *argv);
+            if ((np = rindex(name, '/'))) {
                 *np++ = '\0';
                 if (chdir(*name ? name : "/") < 0) {
                     perror(*name ? name : "/");
@@ -80,9 +80,7 @@ again:
 
 DIR *dirp = NULL;
 
-long
-descend(base, name)
-    char *base, *name;
+long descend(char *base, char *name)
 {
     char *ebase0, *ebase;
     struct stat stb;
@@ -99,7 +97,7 @@ descend(base, name)
         *ebase0 = 0;
         return (0);
     }
-    if (stb.st_nlink > 1 && (stb.st_mode&S_IFMT) != S_IFDIR) {
+    if (stb.st_nlink > 1 && (stb.st_mode & S_IFMT) != S_IFDIR) {
         for (i = 0; i <= mlx; i++)
             if (ml[i].ino == stb.st_ino && ml[i].dev == stb.st_dev)
                 return (0);
@@ -110,7 +108,7 @@ descend(base, name)
         }
     }
     blocks = stb.st_blocks;
-    if ((stb.st_mode&S_IFMT) != S_IFDIR) {
+    if ((stb.st_mode & S_IFMT) != S_IFDIR) {
         if (aflg)
             printf("%ld\t%s\n", kb(blocks), base);
         return (blocks);
@@ -130,12 +128,12 @@ descend(base, name)
         dirp = NULL;
         return (0);
     }
-    while (dp = readdir(dirp)) {
+    while ((dp = readdir(dirp))) {
         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
             continue;
-        (void) sprintf(ebase, "/%s", dp->d_name);
+        (void)sprintf(ebase, "/%s", dp->d_name);
         curoff = telldir(dirp);
-        blocks += descend(base, ebase+1);
+        blocks += descend(base, ebase + 1);
         *ebase = 0;
         if (dirp == NULL) {
             dirp = opendir(".");
@@ -151,7 +149,7 @@ descend(base, name)
     if (sflg == 0)
         printf("%ld\t%s\n", kb(blocks), base);
     if (chdir("..") < 0) {
-        (void) sprintf(index(base, 0), "/..");
+        (void)sprintf(index(base, 0), "/..");
         perror(base);
         exit(1);
     }
diff --git a/src/cmd/echo.c b/src/cmd/echo.c
index 31a1d42..38770f2 100644
--- a/src/cmd/echo.c
+++ b/src/cmd/echo.c
@@ -1,24 +1,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-main(argc, argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
 {
-    register int i, nflg;
+    int i, nflg;
 
     nflg = 0;
-    if(argc > 1 && argv[1][0] == '-' && argv[1][1] == 'n' && !argv[1][2]) {
+    if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'n' && !argv[1][2]) {
         nflg++;
         argc--;
         argv++;
     }
-    for(i=1; i<argc; i++) {
+    for (i = 1; i < argc; i++) {
         fputs(argv[i], stdout);
-        if (i < argc-1)
+        if (i < argc - 1)
             putchar(' ');
     }
-    if(nflg == 0)
+    if (nflg == 0)
         putchar('\n');
     exit(0);
 }
diff --git a/src/cmd/ed.c b/src/cmd/ed.c
index a153605..890162a 100644
--- a/src/cmd/ed.c
+++ b/src/cmd/ed.c
@@ -1,83 +1,84 @@
 /*
  * Editor
  */
-#include <stdlib.h>
-#include <signal.h>
 #include <sgtty.h>
+#include <signal.h>
+#include <stdlib.h>
 #undef CEOF
 #include <setjmp.h>
 #include <unistd.h>
+#include <fcntl.h>
+#include <sys/wait.h>
 
-#define NULL    0
-#define FNSIZE  64
-#define LBSIZE  512
-#define ESIZE   128
-#define GBSIZE  256
-#define NBRA    5
+#define NULL 0
+#define FNSIZE 64
+#define LBSIZE 512
+#define ESIZE 128
+#define GBSIZE 256
+#define NBRA 5
 #define EOF -1
 
-#define CBRA    1
-#define CCHR    2
-#define CDOT    4
+#define CBRA 1
+#define CCHR 2
+#define CDOT 4
 #define CCL 6
-#define NCCL    8
-#define CDOL    10
-#define CEOF    11
-#define CKET    12
-#define CBACK   14
+#define NCCL 8
+#define CDOL 10
+#define CEOF 11
+#define CKET 12
+#define CBACK 14
 
-#define STAR    01
+#define STAR 01
 
-char    Q[] = "";
-char    T[] = "TMP";
-#define READ    0
-#define WRITE   1
+char Q[] = "";
+char T[] = "TMP";
+#define READ 0
+#define WRITE 1
 
 int peekc;
 int lastc;
-char    savedfile[FNSIZE];
-char    file[FNSIZE];
-char    linebuf[LBSIZE];
-char    rhsbuf[LBSIZE/2];
-char    expbuf[ESIZE+4];
+char savedfile[FNSIZE];
+char file[FNSIZE];
+char linebuf[LBSIZE];
+char rhsbuf[LBSIZE / 2];
+char expbuf[ESIZE + 4];
 int circfl;
 int *zero;
 int *dot;
 int *dol;
 int *addr1;
 int *addr2;
-char    genbuf[LBSIZE];
-long    count;
-char    *nextip;
-char    *linebp;
+char genbuf[LBSIZE];
+long count;
+char *nextip;
+char *linebp;
 int ninbuf;
 int io;
 int pflag;
-sig_t   oldhup;
-sig_t   oldquit;
-int vflag   = 1;
-
+sig_t oldhup;
+sig_t oldquit;
+int vflag = 1;
 
 int listf;
 int col;
-char    *globp;
-int tfile   = -1;
+char *globp;
+int tfile = -1;
 int tline;
-char    *tfname;
-char    *loc1;
-char    *loc2;
-char    *locs;
-char    ibuff[512];
-int iblock  = -1;
-char    obuff[512];
-int oblock  = -1;
+char *tfname;
+char *loc1;
+char *loc2;
+char *locs;
+char ibuff[512];
+int iblock = -1;
+char obuff[512];
+int oblock = -1;
 int ichanged;
 int nleft;
-char    WRERR[] = "WRITE ERROR";
+char WRERR[] = "WRITE ERROR";
 int names[26];
 int anymarks;
-char    *braslist[NBRA];
-char    *braelist[NBRA];
+char *braslist[NBRA];
+char *braelist[NBRA];
 int nbra;
 int subnewa;
 int subolda;
@@ -85,17 +86,51 @@ int fchange;
 int wrapp;
 unsigned nlall = 128;
 
-int *address();
-char    *getline();
-char    *getblock();
-char    *place();
 jmp_buf savej;
 
-void
-quit (sig)
-    int sig;
+static void error(char *s);
+static void putchr(int ac);
+static void putstr(char *sp);
+static void putfile(void);
+static void init(void);
+static void commands(void);
+static int *address(void);
+static int getchr(void);
+static void setdot(void);
+static void newline(void);
+static int append(int (*f)(), int *a);
+static void delete(void);
+static void setnoaddr(void);
+static void filename(int comm);
+static void global(int k);
+static void nonzero(void);
+static void join(void);
+static void move(int cflag);
+static char *getline(int tl);
+static void setall(void);
+static void exfile(void);
+static void substitute(int inglob);
+static void putd(void);
+static void callunix(void);
+static void compile(int aeof);
+static int execute(int gf, int *addr);
+static int putline(void);
+static void rdelete(int *ad1, int *ad2);
+static char *getblock(int atl, int iof);
+static void blkio(int b, char *buf, int (*iofcn)());
+static int compsub(void);
+static void dosub(void);
+static int getsub(void);
+static char *place(char *sp, char *l1, char *l2);
+static int getcopy(void);
+static void reverse(int *a1, int *a2);
+static int advance(char *lp, char *ep);
+static int cclass(char *set, char c, int af);
+static int backref(int i, char *lp);
+
+void quit(int sig)
 {
-    if (vflag && fchange && dol!=zero) {
+    if (vflag && fchange && dol != zero) {
         fchange = 0;
         error(Q);
     }
@@ -103,9 +138,7 @@ quit (sig)
     exit(0);
 }
 
-void
-onintr (sig)
-    int sig;
+void onintr(int sig)
 {
     signal(SIGINT, onintr);
     putchr('\n');
@@ -113,38 +146,34 @@ onintr (sig)
     error(Q);
 }
 
-void
-onhup (sig)
-    int sig;
+void onhup(int sig)
 {
     signal(SIGINT, SIG_IGN);
     signal(SIGHUP, SIG_IGN);
     if (dol > zero) {
-        addr1 = zero+1;
+        addr1 = zero + 1;
         addr2 = dol;
         io = creat("ed.hup", 0666);
         if (io > 0)
             putfile();
     }
     fchange = 0;
-    quit();
+    quit(0);
 }
 
-main(argc, argv)
-char **argv;
+int main(int argc, char **argv)
 {
-    register char *p1, *p2;
+    char *p1, *p2;
     sig_t oldintr;
 
-    oldquit = signal (SIGQUIT, SIG_IGN);
-    oldhup = signal (SIGHUP, SIG_IGN);
-    oldintr = signal (SIGINT, SIG_IGN);
-    if ((int)signal (SIGTERM, SIG_IGN) == 0)
-        signal (SIGTERM, quit);
+    oldquit = signal(SIGQUIT, SIG_IGN);
+    oldhup = signal(SIGHUP, SIG_IGN);
+    oldintr = signal(SIGINT, SIG_IGN);
+    if ((int)signal(SIGTERM, SIG_IGN) == 0)
+        signal(SIGTERM, quit);
     argv++;
-    while (argc > 1 && **argv=='-') {
-        switch((*argv)[1]) {
-
+    while (argc > 1 && **argv == '-') {
+        switch ((*argv)[1]) {
         case '\0':
             vflag = 0;
             break;
@@ -153,264 +182,255 @@ char **argv;
             signal(SIGQUIT, SIG_DFL);
             vflag = 1;
             break;
-
         }
         argv++;
         argc--;
     }
 
-    if (argc>1) {
+    if (argc > 1) {
         p1 = *argv;
         p2 = savedfile;
-        while (*p2++ = *p1++)
+        while ((*p2++ = *p1++))
             ;
         globp = "r";
     }
-    zero = (int *)malloc(nlall*sizeof(int));
+    zero = (int *)malloc(nlall * sizeof(int));
     tfname = mktemp("/tmp/eXXXXX");
-    if (! tfname) {
-        putstr ("ed: cannot create /tmp/file");
+    if (!tfname) {
+        putstr("ed: cannot create /tmp/file");
         exit(-1);
     }
     init();
-    if (((int)oldintr&01) == 0)
+    if (((int)oldintr & 01) == 0)
         signal(SIGINT, onintr);
-    if (((int)oldhup&01) == 0)
+    if (((int)oldhup & 01) == 0)
         signal(SIGHUP, onhup);
     setjmp(savej);
     commands();
-    quit();
+    quit(0);
 }
 
-commands()
+void commands()
 {
     int getfile(), gettty();
-    register *a1, c;
+    int *a1, c;
 
     for (;;) {
-    if (pflag) {
-        pflag = 0;
-        addr1 = addr2 = dot;
-        goto print;
-    }
-    addr1 = 0;
-    addr2 = 0;
-    do {
-        addr1 = addr2;
-        if ((a1 = address())==0) {
-            c = getchr();
-            break;
+        if (pflag) {
+            pflag = 0;
+            addr1 = addr2 = dot;
+            goto print;
         }
-        addr2 = a1;
-        if ((c=getchr()) == ';') {
-            c = ',';
-            dot = a1;
-        }
-    } while (c==',');
-    if (addr1==0)
-        addr1 = addr2;
-    switch(c) {
-
-    case 'a':
-        setdot();
-        newline();
-        append(gettty, addr2);
-        continue;
-
-    case 'c':
-        delete();
-        append(gettty, addr1-1);
-        continue;
-
-    case 'd':
-        delete();
-        continue;
-
-    case 'E':
-        fchange = 0;
-        c = 'e';
-    case 'e':
-        setnoaddr();
-        if (vflag && fchange) {
-            fchange = 0;
-            error(Q);
-        }
-        filename(c);
-        init();
-        addr2 = zero;
-        goto caseread;
-
-    case 'f':
-        setnoaddr();
-        filename(c);
-        putstr (savedfile);
-        continue;
-
-    case 'g':
-        global(1);
-        continue;
-
-    case 'i':
-        setdot();
-        nonzero();
-        newline();
-        append(gettty, addr2-1);
-        continue;
-
-
-    case 'j':
-        if (addr2==0) {
-            addr1 = dot;
-            addr2 = dot+1;
-        }
-        setdot();
-        newline();
-        nonzero();
-        join();
-        continue;
-
-    case 'k':
-        if ((c = getchr()) < 'a' || c > 'z')
-            error(Q);
-        newline();
-        setdot();
-        nonzero();
-        names[c-'a'] = *addr2 & ~01;
-        anymarks |= 01;
-        continue;
-
-    case 'm':
-        move(0);
-        continue;
-
-    case '\n':
-        if (addr2==0)
-            addr2 = dot+1;
-        addr1 = addr2;
-        goto print;
-
-    case 'l':
-        listf++;
-    case 'p':
-    case 'P':
-        newline();
-    print:
-        setdot();
-        nonzero();
-        a1 = addr1;
+        addr1 = 0;
+        addr2 = 0;
         do {
-            putstr (getline(*a1++));
-        } while (a1 <= addr2);
-        dot = addr2;
-        listf = 0;
-        continue;
+            addr1 = addr2;
+            if ((a1 = address()) == 0) {
+                c = getchr();
+                break;
+            }
+            addr2 = a1;
+            if ((c = getchr()) == ';') {
+                c = ',';
+                dot = a1;
+            }
+        } while (c == ',');
+        if (addr1 == 0)
+            addr1 = addr2;
+        switch (c) {
+        case 'a':
+            setdot();
+            newline();
+            append(gettty, addr2);
+            continue;
 
-    case 'Q':
-        fchange = 0;
-    case 'q':
-        setnoaddr();
-        newline();
-        quit();
+        case 'c':
+            delete();
+            append(gettty, addr1 - 1);
+            continue;
 
-    case 'r':
-        filename(c);
-    caseread:
-        if ((io = open(file, 0)) < 0) {
-            lastc = '\n';
-            error(file);
-        }
-        setall();
-        ninbuf = 0;
-        c = zero != dol;
-        append(getfile, addr2);
-        exfile();
-        fchange = c;
-        continue;
+        case 'd':
+            delete();
+            continue;
 
-    case 's':
-        setdot();
-        nonzero();
-        substitute(globp!=0);
-        continue;
-
-    case 't':
-        move(1);
-        continue;
-
-    case 'u':
-        setdot();
-        nonzero();
-        newline();
-        if ((*addr2&~01) != subnewa)
-            error(Q);
-        *addr2 = subolda;
-        dot = addr2;
-        continue;
-
-    case 'v':
-        global(0);
-        continue;
-
-    case 'W':
-        wrapp++;
-    case 'w':
-        setall();
-        nonzero();
-        filename(c);
-        if(!wrapp ||
-          ((io = open(file,1)) == -1) ||
-          ((lseek(io, 0L, 2)) == -1))
-            if ((io = creat(file, 0666)) < 0)
-                error(file);
-        wrapp = 0;
-        putfile();
-        exfile();
-        if (addr1==zero+1 && addr2==dol)
+        case 'E':
             fchange = 0;
-        continue;
+            c = 'e';
+        case 'e':
+            setnoaddr();
+            if (vflag && fchange) {
+                fchange = 0;
+                error(Q);
+            }
+            filename(c);
+            init();
+            addr2 = zero;
+            goto caseread;
 
+        case 'f':
+            setnoaddr();
+            filename(c);
+            putstr(savedfile);
+            continue;
 
+        case 'g':
+            global(1);
+            continue;
 
-    case '=':
-        setall();
-        newline();
-        count = (addr2-zero)&077777;
-        putd();
-        putchr('\n');
-        continue;
+        case 'i':
+            setdot();
+            nonzero();
+            newline();
+            append(gettty, addr2 - 1);
+            continue;
 
-    case '!':
-        callunix();
-        continue;
+        case 'j':
+            if (addr2 == 0) {
+                addr1 = dot;
+                addr2 = dot + 1;
+            }
+            setdot();
+            newline();
+            nonzero();
+            join();
+            continue;
 
-    case EOF:
-        return;
+        case 'k':
+            if ((c = getchr()) < 'a' || c > 'z')
+                error(Q);
+            newline();
+            setdot();
+            nonzero();
+            names[c - 'a'] = *addr2 & ~01;
+            anymarks |= 01;
+            continue;
 
-    }
-    error(Q);
+        case 'm':
+            move(0);
+            continue;
+
+        case '\n':
+            if (addr2 == 0)
+                addr2 = dot + 1;
+            addr1 = addr2;
+            goto print;
+
+        case 'l':
+            listf++;
+        case 'p':
+        case 'P':
+            newline();
+        print:
+            setdot();
+            nonzero();
+            a1 = addr1;
+            do {
+                putstr(getline(*a1++));
+            } while (a1 <= addr2);
+            dot = addr2;
+            listf = 0;
+            continue;
+
+        case 'Q':
+            fchange = 0;
+        case 'q':
+            setnoaddr();
+            newline();
+            quit(0);
+
+        case 'r':
+            filename(c);
+        caseread:
+            if ((io = open(file, 0)) < 0) {
+                lastc = '\n';
+                error(file);
+            }
+            setall();
+            ninbuf = 0;
+            c = zero != dol;
+            append(getfile, addr2);
+            exfile();
+            fchange = c;
+            continue;
+
+        case 's':
+            setdot();
+            nonzero();
+            substitute(globp != 0);
+            continue;
+
+        case 't':
+            move(1);
+            continue;
+
+        case 'u':
+            setdot();
+            nonzero();
+            newline();
+            if ((*addr2 & ~01) != subnewa)
+                error(Q);
+            *addr2 = subolda;
+            dot = addr2;
+            continue;
+
+        case 'v':
+            global(0);
+            continue;
+
+        case 'W':
+            wrapp++;
+        case 'w':
+            setall();
+            nonzero();
+            filename(c);
+            if (!wrapp || ((io = open(file, 1)) == -1) || ((lseek(io, 0L, 2)) == -1))
+                if ((io = creat(file, 0666)) < 0)
+                    error(file);
+            wrapp = 0;
+            putfile();
+            exfile();
+            if (addr1 == zero + 1 && addr2 == dol)
+                fchange = 0;
+            continue;
+
+        case '=':
+            setall();
+            newline();
+            count = (addr2 - zero) & 077777;
+            putd();
+            putchr('\n');
+            continue;
+
+        case '!':
+            callunix();
+            continue;
+
+        case EOF:
+            return;
+        }
+        error(Q);
     }
 }
 
-int *
-address()
+int *address()
 {
-    register *a1, minus, c;
+    int *a1, minus, c;
     int n, relerr;
 
     minus = 0;
     a1 = 0;
     for (;;) {
         c = getchr();
-        if ('0'<=c && c<='9') {
+        if ('0' <= c && c <= '9') {
             n = 0;
             do {
                 n *= 10;
                 n += c - '0';
-            } while ((c = getchr())>='0' && c<='9');
+            } while ((c = getchr()) >= '0' && c <= '9');
             peekc = c;
-            if (a1==0)
+            if (a1 == 0)
                 a1 = zero;
-            if (minus<0)
+            if (minus < 0)
                 n = -n;
             a1 += n;
             minus = 0;
@@ -419,21 +439,21 @@ address()
         relerr = 0;
         if (a1 || minus)
             relerr++;
-        switch(c) {
+        switch (c) {
         case ' ':
         case '\t':
             continue;
 
         case '+':
             minus++;
-            if (a1==0)
+            if (a1 == 0)
                 a1 = dot;
             continue;
 
         case '-':
         case '^':
             minus--;
-            if (a1==0)
+            if (a1 == 0)
                 a1 = dot;
             continue;
 
@@ -442,7 +462,7 @@ address()
             compile(c);
             a1 = dot;
             for (;;) {
-                if (c=='/') {
+                if (c == '/') {
                     a1++;
                     if (a1 > dol)
                         a1 = zero;
@@ -453,7 +473,7 @@ address()
                 }
                 if (execute(0, a1))
                     break;
-                if (a1==dot)
+                if (a1 == dot)
                     error(Q);
             }
             break;
@@ -469,26 +489,26 @@ address()
         case '\'':
             if ((c = getchr()) < 'a' || c > 'z')
                 error(Q);
-            for (a1=zero; a1<=dol; a1++)
-                if (names[c-'a'] == (*a1 & ~01))
+            for (a1 = zero; a1 <= dol; a1++)
+                if (names[c - 'a'] == (*a1 & ~01))
                     break;
             break;
 
         default:
             peekc = c;
-            if (a1==0)
-                return(0);
+            if (a1 == 0)
+                return (0);
             a1 += minus;
-            if (a1<zero || a1>dol)
+            if (a1 < zero || a1 > dol)
                 error(Q);
-            return(a1);
+            return (a1);
         }
         if (relerr)
             error(Q);
     }
 }
 
-setdot()
+void setdot()
 {
     if (addr2 == 0)
         addr1 = addr2 = dot;
@@ -496,38 +516,38 @@ setdot()
         error(Q);
 }
 
-setall()
+void setall()
 {
-    if (addr2==0) {
-        addr1 = zero+1;
+    if (addr2 == 0) {
+        addr1 = zero + 1;
         addr2 = dol;
-        if (dol==zero)
+        if (dol == zero)
             addr1 = zero;
     }
     setdot();
 }
 
-setnoaddr()
+void setnoaddr()
 {
     if (addr2)
         error(Q);
 }
 
-nonzero()
+void nonzero()
 {
-    if (addr1<=zero || addr2>dol)
+    if (addr1 <= zero || addr2 > dol)
         error(Q);
 }
 
-newline()
+void newline()
 {
-    register c;
+    int c;
 
     if ((c = getchr()) == '\n')
         return;
-    if (c=='p' || c=='l') {
+    if (c == 'p' || c == 'l') {
         pflag++;
-        if (c=='l')
+        if (c == 'l')
             listf++;
         if (getchr() == '\n')
             return;
@@ -535,44 +555,44 @@ newline()
     error(Q);
 }
 
-filename(comm)
+void filename(int comm)
 {
-    register char *p1, *p2;
-    register c;
+    char *p1, *p2;
+    int c;
 
     count = 0;
     c = getchr();
-    if (c=='\n' || c==EOF) {
+    if (c == '\n' || c == EOF) {
         p1 = savedfile;
-        if (*p1==0 && comm!='f')
+        if (*p1 == 0 && comm != 'f')
             error(Q);
         p2 = file;
-        while (*p2++ = *p1++)
+        while ((*p2++ = *p1++))
             ;
         return;
     }
-    if (c!=' ')
+    if (c != ' ')
         error(Q);
     while ((c = getchr()) == ' ')
         ;
-    if (c=='\n')
+    if (c == '\n')
         error(Q);
     p1 = file;
     do {
         *p1++ = c;
-        if (c==' ' || c==EOF)
+        if (c == ' ' || c == EOF)
             error(Q);
     } while ((c = getchr()) != '\n');
     *p1++ = 0;
-    if (savedfile[0]==0 || comm=='e' || comm=='f') {
+    if (savedfile[0] == 0 || comm == 'e' || comm == 'f') {
         p1 = savedfile;
         p2 = file;
-        while (*p1++ = *p2++)
+        while ((*p1++ = *p2++))
             ;
     }
 }
 
-exfile()
+void exfile()
 {
     close(io);
     io = -1;
@@ -582,15 +602,14 @@ exfile()
     }
 }
 
-error(s)
-char *s;
+void error(char *s)
 {
-    register c;
+    int c;
 
     wrapp = 0;
     listf = 0;
     putchr('?');
-    putstr (s);
+    putstr(s);
     count = 0;
     lseek(0, (long)0, 2);
     pflag = 0;
@@ -598,7 +617,7 @@ char *s;
         lastc = '\n';
     globp = 0;
     peekc = lastc;
-    if(lastc)
+    if (lastc)
         while ((c = getchr()) != '\n' && c != EOF)
             ;
     if (io > 0) {
@@ -608,64 +627,64 @@ char *s;
     longjmp(savej, 1);
 }
 
-getchr()
+int getchr()
 {
     char c;
-    if (lastc=peekc) {
+    if ((lastc = peekc)) {
         peekc = 0;
-        return(lastc);
+        return (lastc);
     }
     if (globp) {
         if ((lastc = *globp++) != 0)
-            return(lastc);
+            return (lastc);
         globp = 0;
-        return(EOF);
+        return (EOF);
     }
     if (read(0, &c, 1) <= 0)
-        return(lastc = EOF);
-    lastc = c&0177;
-    return(lastc);
+        return (lastc = EOF);
+    lastc = c & 0177;
+    return (lastc);
 }
 
-gettty()
+int gettty()
 {
-    register c;
-    register char *gf;
-    register char *p;
+    int c;
+    char *gf;
+    char *p;
 
     p = linebuf;
     gf = globp;
     while ((c = getchr()) != '\n') {
-        if (c==EOF) {
+        if (c == EOF) {
             if (gf)
                 peekc = c;
-            return(c);
+            return (c);
         }
         if ((c &= 0177) == 0)
             continue;
         *p++ = c;
-        if (p >= &linebuf[LBSIZE-2])
+        if (p >= &linebuf[LBSIZE - 2])
             error(Q);
     }
     *p++ = 0;
-    if (linebuf[0]=='.' && linebuf[1]==0)
-        return(EOF);
-    return(0);
+    if (linebuf[0] == '.' && linebuf[1] == 0)
+        return (EOF);
+    return (0);
 }
 
-getfile()
+int getfile()
 {
-    register c;
-    register char *lp, *fp;
+    int c;
+    char *lp, *fp;
 
     lp = linebuf;
     fp = nextip;
     do {
         if (--ninbuf < 0) {
-            if ((ninbuf = read(io, genbuf, LBSIZE)-1) < 0)
-                return(EOF);
+            if ((ninbuf = read(io, genbuf, LBSIZE) - 1) < 0)
+                return (EOF);
             fp = genbuf;
-            while(fp < &genbuf[ninbuf]) {
+            while (fp < &genbuf[ninbuf]) {
                 if (*fp++ & 0200) {
                     break;
                 }
@@ -673,9 +692,9 @@ getfile()
             fp = genbuf;
         }
         c = *fp++;
-        if (c=='\0')
+        if (c == '\0')
             continue;
-        if (c&0200 || lp >= &linebuf[LBSIZE]) {
+        if (c & 0200 || lp >= &linebuf[LBSIZE]) {
             lastc = '\n';
             error(Q);
         }
@@ -684,14 +703,14 @@ getfile()
     } while (c != '\n');
     *--lp = 0;
     nextip = fp;
-    return(0);
+    return (0);
 }
 
-putfile()
+void putfile()
 {
     int *a1, n;
-    register char *fp, *lp;
-    register nib;
+    char *fp, *lp;
+    int nib;
 
     nib = 512;
     fp = genbuf;
@@ -700,9 +719,9 @@ putfile()
         lp = getline(*a1++);
         for (;;) {
             if (--nib < 0) {
-                n = fp-genbuf;
-                if(write(io, genbuf, n) != n) {
-                    putstr (WRERR);
+                n = fp - genbuf;
+                if (write(io, genbuf, n) != n) {
+                    putstr(WRERR);
                     error(Q);
                 }
                 nib = 511;
@@ -715,27 +734,25 @@ putfile()
             }
         }
     } while (a1 <= addr2);
-    n = fp-genbuf;
-    if(write(io, genbuf, n) != n) {
-        putstr (WRERR);
+    n = fp - genbuf;
+    if (write(io, genbuf, n) != n) {
+        putstr(WRERR);
         error(Q);
     }
 }
 
-append(f, a)
-int *a;
-int (*f)();
+int append(int (*f)(), int *a)
 {
-    register *a1, *a2, *rdot;
+    int *a1, *a2, *rdot;
     int nline, tl;
 
     nline = 0;
     dot = a;
     while ((*f)() == 0) {
-        if ((dol-zero)+1 >= nlall) {
+        if ((dol - zero) + 1 >= nlall) {
             int *ozero = zero;
             nlall += 512;
-            if ((zero = (int *)realloc((char *)zero, nlall*sizeof(int)))==NULL) {
+            if ((zero = (int *)realloc((char *)zero, nlall * sizeof(int))) == NULL) {
                 lastc = '\n';
                 zero = ozero;
                 error("MEM?");
@@ -746,18 +763,18 @@ int (*f)();
         tl = putline();
         nline++;
         a1 = ++dol;
-        a2 = a1+1;
+        a2 = a1 + 1;
         rdot = ++dot;
         while (a1 > rdot)
             *--a2 = *--a1;
         *rdot = tl;
     }
-    return(nline);
+    return (nline);
 }
 
-callunix()
+void callunix()
 {
-    register pid, rpid;
+    int pid, rpid;
     sig_t savint;
     int retcode;
 
@@ -772,10 +789,10 @@ callunix()
     while ((rpid = wait(&retcode)) != pid && rpid != -1)
         ;
     signal(SIGINT, savint);
-    putstr ("!");
+    putstr("!");
 }
 
-delete()
+void delete()
 {
     setdot();
     newline();
@@ -783,13 +800,12 @@ delete()
     rdelete(addr1, addr2);
 }
 
-rdelete(ad1, ad2)
-int *ad1, *ad2;
+void rdelete(int *ad1, int *ad2)
 {
-    register *a1, *a2, *a3;
+    int *a1, *a2, *a3;
 
     a1 = ad1;
-    a2 = ad2+1;
+    a2 = ad2 + 1;
     a3 = dol;
     dol -= a2 - a1;
     do {
@@ -802,49 +818,48 @@ int *ad1, *ad2;
     fchange = 1;
 }
 
-gdelete()
+void gdelete()
 {
-    register *a1, *a2, *a3;
+    int *a1, *a2, *a3;
 
     a3 = dol;
-    for (a1=zero+1; (*a1&01)==0; a1++)
-        if (a1>=a3)
+    for (a1 = zero + 1; (*a1 & 01) == 0; a1++)
+        if (a1 >= a3)
             return;
-    for (a2=a1+1; a2<=a3;) {
-        if (*a2&01) {
+    for (a2 = a1 + 1; a2 <= a3;) {
+        if (*a2 & 01) {
             a2++;
             dot = a1;
         } else
             *a1++ = *a2++;
     }
-    dol = a1-1;
-    if (dot>dol)
+    dol = a1 - 1;
+    if (dot > dol)
         dot = dol;
     fchange = 1;
 }
 
-char *
-getline(tl)
+char *getline(int tl)
 {
-    register char *bp, *lp;
-    register nl;
+    char *bp, *lp;
+    int nl;
 
     lp = linebuf;
     bp = getblock(tl, READ);
     nl = nleft;
     tl &= ~0377;
-    while (*lp++ = *bp++)
+    while ((*lp++ = *bp++))
         if (--nl == 0) {
-            bp = getblock(tl+=0400, READ);
+            bp = getblock(tl += 0400, READ);
             nl = nleft;
         }
-    return(linebuf);
+    return (linebuf);
 }
 
-putline()
+int putline()
 {
-    register char *bp, *lp;
-    register nl;
+    char *bp, *lp;
+    int nl;
     int tl;
 
     fchange = 1;
@@ -853,75 +868,72 @@ putline()
     bp = getblock(tl, WRITE);
     nl = nleft;
     tl &= ~0377;
-    while (*bp = *lp++) {
+    while ((*bp = *lp++)) {
         if (*bp++ == '\n') {
             *--bp = 0;
             linebp = lp;
             break;
         }
         if (--nl == 0) {
-            bp = getblock(tl+=0400, WRITE);
+            bp = getblock(tl += 0400, WRITE);
             nl = nleft;
         }
     }
     nl = tline;
-    tline += (((lp-linebuf)+03)>>1)&077776;
-    return(nl);
+    tline += (((lp - linebuf) + 03) >> 1) & 077776;
+    return (nl);
 }
 
-char *
-getblock(atl, iof)
+char *getblock(int atl, int iof)
 {
-    register bno, off;
-    register char *p1, *p2;
-    register int n;
+    int bno, off;
+    char *p1, *p2;
+    int n;
 
-    bno = (atl>>8)&0377;
-    off = (atl<<1)&0774;
+    bno = (atl >> 8) & 0377;
+    off = (atl << 1) & 0774;
     if (bno >= 255) {
         lastc = '\n';
         error(T);
     }
     nleft = 512 - off;
-    if (bno==iblock) {
+    if (bno == iblock) {
         ichanged |= iof;
-        return(ibuff+off);
+        return (ibuff + off);
     }
-    if (bno==oblock)
-        return(obuff+off);
-    if (iof==READ) {
+    if (bno == oblock)
+        return (obuff + off);
+    if (iof == READ) {
         if (ichanged) {
             blkio(iblock, ibuff, write);
         }
         ichanged = 0;
         iblock = bno;
         blkio(bno, ibuff, read);
-        return(ibuff+off);
+        return (ibuff + off);
     }
-    if (oblock>=0) {
-            blkio(oblock, obuff, write);
+    if (oblock >= 0) {
+        blkio(oblock, obuff, write);
     }
     oblock = bno;
-    return(obuff+off);
+    return (obuff + off);
 }
 
-blkio(b, buf, iofcn)
-char *buf;
-int (*iofcn)();
+void blkio(int b, char *buf, int (*iofcn)())
 {
-    lseek(tfile, (long)b<<9, 0);
+    lseek(tfile, (long)b << 9, 0);
     if ((*iofcn)(tfile, buf, 512) != 512) {
         error(T);
     }
 }
 
-init()
+void init()
 {
-    register *markp;
+    int *markp;
 
     close(tfile);
     tline = 2;
-    for (markp = names; markp < &names[26]; )
+    for (markp = names; markp < &names[26];)
         *markp++ = 0;
     subnewa = 0;
     anymarks = 0;
@@ -933,48 +945,48 @@ init()
     dot = dol = zero;
 }
 
-global(k)
+void global(int k)
 {
-    register char *gp;
-    register c;
-    register int *a1;
+    char *gp;
+    int c;
+    int *a1;
     char globuf[GBSIZE];
 
     if (globp)
         error(Q);
     setall();
     nonzero();
-    if ((c=getchr())=='\n')
+    if ((c = getchr()) == '\n')
         error(Q);
     compile(c);
     gp = globuf;
     while ((c = getchr()) != '\n') {
-        if (c==EOF)
+        if (c == EOF)
             error(Q);
-        if (c=='\\') {
+        if (c == '\\') {
             c = getchr();
-            if (c!='\n')
+            if (c != '\n')
                 *gp++ = '\\';
         }
         *gp++ = c;
-        if (gp >= &globuf[GBSIZE-2])
+        if (gp >= &globuf[GBSIZE - 2])
             error(Q);
     }
     *gp++ = '\n';
     *gp++ = 0;
-    for (a1=zero; a1<=dol; a1++) {
+    for (a1 = zero; a1 <= dol; a1++) {
         *a1 &= ~01;
-        if (a1>=addr1 && a1<=addr2 && execute(0, a1)==k)
+        if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k)
             *a1 |= 01;
     }
     /*
      * Special case: g/.../d (avoid n^2 algorithm)
      */
-    if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') {
+    if (globuf[0] == 'd' && globuf[1] == '\n' && globuf[2] == '\0') {
         gdelete();
         return;
     }
-    for (a1=zero; a1<=dol; a1++) {
+    for (a1 = zero; a1 <= dol; a1++) {
         if (*a1 & 01) {
             *a1 &= ~01;
             dot = a1;
@@ -985,44 +997,43 @@ global(k)
     }
 }
 
-join()
+void join()
 {
-    register char *gp, *lp;
-    register *a1;
+    char *gp, *lp;
+    int *a1;
 
     gp = genbuf;
-    for (a1=addr1; a1<=addr2; a1++) {
+    for (a1 = addr1; a1 <= addr2; a1++) {
         lp = getline(*a1);
-        while (*gp = *lp++)
-            if (gp++ >= &genbuf[LBSIZE-2])
+        while ((*gp = *lp++))
+            if (gp++ >= &genbuf[LBSIZE - 2])
                 error(Q);
     }
     lp = linebuf;
     gp = genbuf;
-    while (*lp++ = *gp++)
+    while ((*lp++ = *gp++))
         ;
     *addr1 = putline();
-    if (addr1<addr2)
-        rdelete(addr1+1, addr2);
+    if (addr1 < addr2)
+        rdelete(addr1 + 1, addr2);
     dot = addr1;
 }
 
-substitute(inglob)
+void substitute(int inglob)
 {
-    register *markp, *a1, nl;
+    int *markp, *a1, nl;
     int gsubf;
-    int getsub();
 
     gsubf = compsub();
     for (a1 = addr1; a1 <= addr2; a1++) {
         int *ozero;
-        if (execute(0, a1)==0)
+        if (execute(0, a1) == 0)
             continue;
         inglob |= 01;
         dosub();
         if (gsubf) {
             while (*loc2) {
-                if (execute(1, (int *)0)==0)
+                if (execute(1, (int *)0) == 0)
                     break;
                 dosub();
             }
@@ -1038,18 +1049,18 @@ substitute(inglob)
         *a1 = subnewa;
         ozero = zero;
         nl = append(getsub, a1);
-        nl += zero-ozero;
+        nl += zero - ozero;
         a1 += nl;
         addr2 += nl;
     }
-    if (inglob==0)
+    if (inglob == 0)
         error(Q);
 }
 
-compsub()
+int compsub()
 {
-    register seof, c;
-    register char *p;
+    int seof, c;
+    char *p;
 
     if ((seof = getchr()) == '\n' || seof == ' ')
         error(Q);
@@ -1057,46 +1068,46 @@ compsub()
     p = rhsbuf;
     for (;;) {
         c = getchr();
-        if (c=='\\')
+        if (c == '\\')
             c = getchr() | 0200;
-        if (c=='\n') {
+        if (c == '\n') {
             if (globp)
                 c |= 0200;
             else
                 error(Q);
         }
-        if (c==seof)
+        if (c == seof)
             break;
         *p++ = c;
-        if (p >= &rhsbuf[LBSIZE/2])
+        if (p >= &rhsbuf[LBSIZE / 2])
             error(Q);
     }
     *p++ = 0;
     if ((peekc = getchr()) == 'g') {
         peekc = 0;
         newline();
-        return(1);
+        return (1);
     }
     newline();
-    return(0);
+    return (0);
 }
 
-getsub()
+int getsub()
 {
-    register char *p1, *p2;
+    char *p1, *p2;
 
     p1 = linebuf;
     if ((p2 = linebp) == 0)
-        return(EOF);
-    while (*p1++ = *p2++)
+        return (EOF);
+    while ((*p1++ = *p2++))
         ;
     linebp = 0;
-    return(0);
+    return (0);
 }
 
-dosub()
+void dosub()
 {
-    register char *lp, *sp, *rp;
+    char *lp, *sp, *rp;
     int c;
 
     lp = linebuf;
@@ -1104,50 +1115,46 @@ dosub()
     rp = rhsbuf;
     while (lp < loc1)
         *sp++ = *lp++;
-    while (c = *rp++&0377) {
-        if (c=='&') {
+    while ((c = *rp++ & 0377)) {
+        if (c == '&') {
             sp = place(sp, loc1, loc2);
             continue;
-        } else if (c&0200 && (c &= 0177) >='1' && c < nbra+'1') {
-            sp = place(sp, braslist[c-'1'], braelist[c-'1']);
+        } else if (c & 0200 && (c &= 0177) >= '1' && c < nbra + '1') {
+            sp = place(sp, braslist[c - '1'], braelist[c - '1']);
             continue;
         }
-        *sp++ = c&0177;
+        *sp++ = c & 0177;
         if (sp >= &genbuf[LBSIZE])
             error(Q);
     }
     lp = loc2;
     loc2 = sp - genbuf + linebuf;
-    while (*sp++ = *lp++)
+    while ((*sp++ = *lp++))
         if (sp >= &genbuf[LBSIZE])
             error(Q);
     lp = linebuf;
     sp = genbuf;
-    while (*lp++ = *sp++)
+    while ((*lp++ = *sp++))
         ;
 }
 
-char *
-place(sp, l1, l2)
-register char *sp, *l1, *l2;
+char *place(char *sp, char *l1, char *l2)
 {
-
     while (l1 < l2) {
         *sp++ = *l1++;
         if (sp >= &genbuf[LBSIZE])
             error(Q);
     }
-    return(sp);
+    return (sp);
 }
 
-move(cflag)
+void move(int cflag)
 {
-    register int *adt, *ad1, *ad2;
-    int getcopy();
+    int *adt, *ad1, *ad2;
 
     setdot();
     nonzero();
-    if ((adt = address())==0)
+    if ((adt = address()) == 0)
         error(Q);
     newline();
     if (cflag) {
@@ -1166,9 +1173,9 @@ move(cflag)
         ad1 = addr1;
     }
     ad2++;
-    if (adt<ad1) {
-        dot = adt + (ad2-ad1);
-        if ((++adt)==ad1)
+    if (adt < ad1) {
+        dot = adt + (ad2 - ad1);
+        if ((++adt) == ad1)
             return;
         reverse(adt, ad1);
         reverse(ad1, ad2);
@@ -1183,10 +1190,9 @@ move(cflag)
     fchange = 1;
 }
 
-reverse(a1, a2)
-register int *a1, *a2;
+void reverse(int *a1, int *a2)
 {
-    register int t;
+    int t;
 
     for (;;) {
         t = *--a2;
@@ -1197,18 +1203,18 @@ register int *a1, *a2;
     }
 }
 
-getcopy()
+int getcopy()
 {
     if (addr1 > addr2)
-        return(EOF);
+        return (EOF);
     getline(*addr1++);
-    return(0);
+    return (0);
 }
 
-compile(aeof)
+void compile(int aeof)
 {
-    register eof, c;
-    register char *ep;
+    int eof, c;
+    char *ep;
     char *lastep;
     char bracket[NBRA], *bracketp;
     int cclcnt;
@@ -1217,13 +1223,13 @@ compile(aeof)
     eof = aeof;
     bracketp = bracket;
     if ((c = getchr()) == eof) {
-        if (*ep==0)
+        if (*ep == 0)
             error(Q);
         return;
     }
     circfl = 0;
     nbra = 0;
-    if (c=='^') {
+    if (c == '^') {
         c = getchr();
         circfl++;
     }
@@ -1233,18 +1239,17 @@ compile(aeof)
         if (ep >= &expbuf[ESIZE])
             goto cerror;
         c = getchr();
-        if (c==eof) {
+        if (c == eof) {
             if (bracketp != bracket)
                 goto cerror;
             *ep++ = CEOF;
             return;
         }
-        if (c!='*')
+        if (c != '*')
             lastep = ep;
         switch (c) {
-
         case '\\':
-            if ((c = getchr())=='(') {
+            if ((c = getchr()) == '(') {
                 if (nbra >= NBRA)
                     goto cerror;
                 *bracketp++ = nbra;
@@ -1259,13 +1264,13 @@ compile(aeof)
                 *ep++ = *--bracketp;
                 continue;
             }
-            if (c>='1' && c<'1'+NBRA) {
+            if (c >= '1' && c < '1' + NBRA) {
                 *ep++ = CBACK;
-                *ep++ = c-'1';
+                *ep++ = c - '1';
                 continue;
             }
             *ep++ = CCHR;
-            if (c=='\n')
+            if (c == '\n')
                 goto cerror;
             *ep++ = c;
             continue;
@@ -1278,13 +1283,13 @@ compile(aeof)
             goto cerror;
 
         case '*':
-            if (lastep==0 || *lastep==CBRA || *lastep==CKET)
+            if (lastep == 0 || *lastep == CBRA || *lastep == CKET)
                 goto defchar;
             *lastep |= STAR;
             continue;
 
         case '$':
-            if ((peekc=getchr()) != eof)
+            if ((peekc = getchr()) != eof)
                 goto defchar;
             *ep++ = CDOL;
             continue;
@@ -1293,24 +1298,24 @@ compile(aeof)
             *ep++ = CCL;
             *ep++ = 0;
             cclcnt = 1;
-            if ((c=getchr()) == '^') {
+            if ((c = getchr()) == '^') {
                 c = getchr();
                 ep[-2] = NCCL;
             }
             do {
-                if (c=='\n')
+                if (c == '\n')
                     goto cerror;
-                if (c=='-' && ep[-1]!=0) {
-                    if ((c=getchr())==']') {
+                if (c == '-' && ep[-1] != 0) {
+                    if ((c = getchr()) == ']') {
                         *ep++ = '-';
                         cclcnt++;
                         break;
                     }
-                    while (ep[-1]<c) {
-                        *ep = ep[-1]+1;
+                    while (ep[-1] < c) {
+                        *ep = ep[-1] + 1;
                         ep++;
                         cclcnt++;
-                        if (ep>=&expbuf[ESIZE])
+                        if (ep >= &expbuf[ESIZE])
                             goto cerror;
                     }
                 }
@@ -1328,210 +1333,204 @@ compile(aeof)
             *ep++ = c;
         }
     }
-   cerror:
+cerror:
     expbuf[0] = 0;
     nbra = 0;
     error(Q);
 }
 
-execute(gf, addr)
-int *addr;
+int execute(int gf, int *addr)
 {
-    register char *p1, *p2, c;
+    char *p1, *p2, c;
 
-    for (c=0; c<NBRA; c++) {
+    for (c = 0; c < NBRA; c++) {
         braslist[c] = 0;
         braelist[c] = 0;
     }
     if (gf) {
         if (circfl)
-            return(0);
+            return (0);
         p1 = linebuf;
         p2 = genbuf;
-        while (*p1++ = *p2++)
+        while ((*p1++ = *p2++))
             ;
         locs = p1 = loc2;
     } else {
-        if (addr==zero)
-            return(0);
+        if (addr == zero)
+            return (0);
         p1 = getline(*addr);
         locs = 0;
     }
     p2 = expbuf;
     if (circfl) {
         loc1 = p1;
-        return(advance(p1, p2));
+        return (advance(p1, p2));
     }
     /* fast check for first character */
-    if (*p2==CCHR) {
+    if (*p2 == CCHR) {
         c = p2[1];
         do {
-            if (*p1!=c)
+            if (*p1 != c)
                 continue;
             if (advance(p1, p2)) {
                 loc1 = p1;
-                return(1);
+                return (1);
             }
         } while (*p1++);
-        return(0);
+        return (0);
     }
     /* regular algorithm */
     do {
         if (advance(p1, p2)) {
             loc1 = p1;
-            return(1);
+            return (1);
         }
     } while (*p1++);
-    return(0);
+    return (0);
 }
 
-advance(lp, ep)
-register char *ep, *lp;
+int advance(char *lp, char *ep)
 {
-    register char *curlp;
+    char *curlp;
     int i;
 
-    for (;;) switch (*ep++) {
+    for (;;)
+        switch (*ep++) {
+        case CCHR:
+            if (*ep++ == *lp++)
+                continue;
+            return (0);
 
-    case CCHR:
-        if (*ep++ == *lp++)
+        case CDOT:
+            if (*lp++)
+                continue;
+            return (0);
+
+        case CDOL:
+            if (*lp == 0)
+                continue;
+            return (0);
+
+        case CEOF:
+            loc2 = lp;
+            return (1);
+
+        case CCL:
+            if (cclass(ep, *lp++, 1)) {
+                ep += *ep;
+                continue;
+            }
+            return (0);
+
+        case NCCL:
+            if (cclass(ep, *lp++, 0)) {
+                ep += *ep;
+                continue;
+            }
+            return (0);
+
+        case CBRA:
+            braslist[*ep++] = lp;
             continue;
-        return(0);
 
-    case CDOT:
-        if (*lp++)
+        case CKET:
+            braelist[*ep++] = lp;
             continue;
-        return(0);
 
-    case CDOL:
-        if (*lp==0)
+        case CBACK:
+            if (braelist[i = *ep++] == 0)
+                error(Q);
+            if (backref(i, lp)) {
+                lp += braelist[i] - braslist[i];
+                continue;
+            }
+            return (0);
+
+        case CBACK | STAR:
+            if (braelist[i = *ep++] == 0)
+                error(Q);
+            curlp = lp;
+            while (backref(i, lp))
+                lp += braelist[i] - braslist[i];
+            while (lp >= curlp) {
+                if (advance(lp, ep))
+                    return (1);
+                lp -= braelist[i] - braslist[i];
+            }
             continue;
-        return(0);
 
-    case CEOF:
-        loc2 = lp;
-        return(1);
+        case CDOT | STAR:
+            curlp = lp;
+            while (*lp++)
+                ;
+            goto star;
 
-    case CCL:
-        if (cclass(ep, *lp++, 1)) {
+        case CCHR | STAR:
+            curlp = lp;
+            while (*lp++ == *ep)
+                ;
+            ep++;
+            goto star;
+
+        case CCL | STAR:
+        case NCCL | STAR:
+            curlp = lp;
+            while (cclass(ep, *lp++, ep[-1] == (CCL | STAR)))
+                ;
             ep += *ep;
-            continue;
-        }
-        return(0);
+            goto star;
 
-    case NCCL:
-        if (cclass(ep, *lp++, 0)) {
-            ep += *ep;
-            continue;
-        }
-        return(0);
+        star:
+            do {
+                lp--;
+                if (lp == locs)
+                    break;
+                if (advance(lp, ep))
+                    return (1);
+            } while (lp > curlp);
+            return (0);
 
-    case CBRA:
-        braslist[*ep++] = lp;
-        continue;
-
-    case CKET:
-        braelist[*ep++] = lp;
-        continue;
-
-    case CBACK:
-        if (braelist[i = *ep++]==0)
+        default:
             error(Q);
-        if (backref(i, lp)) {
-            lp += braelist[i] - braslist[i];
-            continue;
         }
-        return(0);
-
-    case CBACK|STAR:
-        if (braelist[i = *ep++] == 0)
-            error(Q);
-        curlp = lp;
-        while (backref(i, lp))
-            lp += braelist[i] - braslist[i];
-        while (lp >= curlp) {
-            if (advance(lp, ep))
-                return(1);
-            lp -= braelist[i] - braslist[i];
-        }
-        continue;
-
-    case CDOT|STAR:
-        curlp = lp;
-        while (*lp++)
-            ;
-        goto star;
-
-    case CCHR|STAR:
-        curlp = lp;
-        while (*lp++ == *ep)
-            ;
-        ep++;
-        goto star;
-
-    case CCL|STAR:
-    case NCCL|STAR:
-        curlp = lp;
-        while (cclass(ep, *lp++, ep[-1]==(CCL|STAR)))
-            ;
-        ep += *ep;
-        goto star;
-
-    star:
-        do {
-            lp--;
-            if (lp==locs)
-                break;
-            if (advance(lp, ep))
-                return(1);
-        } while (lp > curlp);
-        return(0);
-
-    default:
-        error(Q);
-    }
 }
 
-backref(i, lp)
-register i;
-register char *lp;
+int backref(int i, char *lp)
 {
-    register char *bp;
+    char *bp;
 
     bp = braslist[i];
     while (*bp++ == *lp++)
         if (bp >= braelist[i])
-            return(1);
-    return(0);
+            return (1);
+    return (0);
 }
 
-cclass(set, c, af)
-register char *set, c;
+int cclass(char *set, char c, int af)
 {
-    register n;
+    int n;
 
-    if (c==0)
-        return(0);
+    if (c == 0)
+        return (0);
     n = *set++;
     while (--n)
         if (*set++ == c)
-            return(af);
-    return(!af);
+            return (af);
+    return (!af);
 }
 
-putd()
+void putd()
 {
-    register r;
+    int r;
 
-    r = count%10;
+    r = count % 10;
     count /= 10;
     if (count)
         putd();
     putchr(r + '0');
 }
 
-putstr (sp)
-register char *sp;
+void putstr(char *sp)
 {
     col = 0;
     while (*sp)
@@ -1539,13 +1538,13 @@ register char *sp;
     putchr('\n');
 }
 
-char    line[70];
-char    *linp   = line;
+char line[70];
+char *linp = line;
 
-putchr(ac)
+void putchr(int ac)
 {
-    register char *lp;
-    register c;
+    char *lp;
+    int c;
 
     lp = linp;
     c = ac;
@@ -1556,11 +1555,11 @@ putchr(ac)
             *lp++ = '\\';
             *lp++ = '\n';
         }
-        if (c=='\t') {
+        if (c == '\t') {
             c = '>';
             goto esc;
         }
-        if (c=='\b') {
+        if (c == '\b') {
             c = '<';
         esc:
             *lp++ = '-';
@@ -1568,19 +1567,19 @@ putchr(ac)
             *lp++ = c;
             goto out;
         }
-        if (c<' ' && c!= '\n') {
+        if (c < ' ' && c != '\n') {
             *lp++ = '\\';
-            *lp++ = (c>>3)+'0';
-            *lp++ = (c&07)+'0';
+            *lp++ = (c >> 3) + '0';
+            *lp++ = (c & 07) + '0';
             col += 2;
             goto out;
         }
     }
     *lp++ = c;
 out:
-    if(c == '\n' || lp >= &line[64]) {
+    if (c == '\n' || lp >= &line[64]) {
         linp = line;
-        write(1, line, lp-line);
+        write(1, line, lp - line);
         return;
     }
     linp = lp;
diff --git a/src/cmd/fgrep.c b/src/cmd/fgrep.c
index f589f45..c78faf1 100644
--- a/src/cmd/fgrep.c
+++ b/src/cmd/fgrep.c
@@ -6,9 +6,11 @@
  *      1 - ok, but no matches
  *      2 - some error
  */
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 
@@ -18,31 +20,34 @@
 #define QSIZE 400
 
 struct words {
-    char    inp;
-    char    out;
-    struct  words *nst;
-    struct  words *link;
-    struct  words *fail;
+    char inp;
+    char out;
+    struct words *nst;
+    struct words *link;
+    struct words *fail;
 } w[MAXSIZ], *smax, *q;
 
-long    lnum;
+long lnum;
 int bflag, cflag, fflag, lflag, nflag, vflag, xflag, yflag;
-int hflag   = 1;
+int hflag = 1;
 int sflag;
 int retcode = 0;
 int nfile;
-long    blkno;
+long blkno;
 int nsucc;
-long    tln;
-FILE    *wordf;
-char    *argptr;
+long tln;
+FILE *wordf;
+char *argptr;
 
-main(argc, argv)
-char **argv;
+static void cgotofn(void);
+static void cfail(void);
+static void execute(char *file);
+static void overflo(void);
+
+int main(int argc, char **argv)
 {
-    while (--argc > 0 && (++argv)[0][0]=='-')
+    while (--argc > 0 && (++argv)[0][0] == '-')
         switch (argv[0][1]) {
-
         case 's':
             sflag++;
             continue;
@@ -84,8 +89,8 @@ char **argv;
             xflag++;
             continue;
 
-        case 'i':       /* Berkeley */
-        case 'y':       /* Btl */
+        case 'i': /* Berkeley */
+        case 'y': /* Btl */
             yflag++;
             continue;
         default:
@@ -93,43 +98,43 @@ char **argv;
             continue;
         }
 out:
-    if (argc<=0)
+    if (argc <= 0)
         exit(2);
     if (fflag) {
         wordf = fopen(*argv, "r");
-        if (wordf==NULL) {
+        if (wordf == NULL) {
             fprintf(stderr, "fgrep: can't open %s\n", *argv);
             exit(2);
         }
-    }
-    else argptr = *argv;
+    } else
+        argptr = *argv;
     argc--;
     argv++;
 
     cgotofn();
     cfail();
     nfile = argc;
-    if (argc<=0) {
-        if (lflag) exit(1);
+    if (argc <= 0) {
+        if (lflag)
+            exit(1);
         execute((char *)NULL);
-    }
-    else while (--argc >= 0) {
-        execute(*argv);
-        argv++;
-    }
+    } else
+        while (--argc >= 0) {
+            execute(*argv);
+            argv++;
+        }
     exit(retcode != 0 ? retcode : nsucc == 0);
 }
 
-#define ccomp(a,b) (yflag ? lca(a)==lca(b) : a==b)
+#define ccomp(a, b) (yflag ? lca(a) == lca(b) : a == b)
 #define lca(x) (isupper(x) ? tolower(x) : x)
 
-execute(file)
-char *file;
+void execute(char *file)
 {
-    register struct words *c;
-    register ccount;
-    register char ch;
-    register char *p;
+    struct words *c;
+    int ccount;
+    char ch;
+    char *p;
     static char *buf;
     static int blksize;
     struct stat stb;
@@ -142,14 +147,14 @@ char *file;
             retcode = 2;
             return;
         }
-    }
-    else f = 0;
+    } else
+        f = 0;
     if (buf == NULL) {
         if (fstat(f, &stb) >= 0 && stb.st_blksize > 0)
             blksize = stb.st_blksize;
         else
             blksize = BLKSIZE;
-        buf = (char *)malloc(2*blksize);
+        buf = (char *)malloc(2 * blksize);
         if (buf == NULL) {
             fprintf(stderr, "egrep: no memory for %s\n", file);
             retcode = 2;
@@ -166,83 +171,93 @@ char *file;
     c = w;
     for (;;) {
         if (--ccount <= 0) {
-            if (p == &buf[2*blksize]) p = buf;
+            if (p == &buf[2 * blksize])
+                p = buf;
             if (p > &buf[blksize]) {
-                if ((ccount = read(f, p, &buf[2*blksize] - p)) <= 0) break;
-            }
-            else if ((ccount = read(f, p, blksize)) <= 0) break;
+                if ((ccount = read(f, p, &buf[2 * blksize] - p)) <= 0)
+                    break;
+            } else if ((ccount = read(f, p, blksize)) <= 0)
+                break;
             blkno += ccount;
         }
-        nstate:
-            if (ccomp(c->inp, *p)) {
-                c = c->nst;
-            }
-            else if (c->link != 0) {
-                c = c->link;
-                goto nstate;
-            }
-            else {
-                c = c->fail;
-                failed = 1;
-                if (c==0) {
-                    c = w;
-                    istate:
-                    if (ccomp(c->inp ,  *p)) {
-                        c = c->nst;
-                    }
-                    else if (c->link != 0) {
-                        c = c->link;
-                        goto istate;
-                    }
+nstate:
+        if (ccomp(c->inp, *p)) {
+            c = c->nst;
+        } else if (c->link != 0) {
+            c = c->link;
+            goto nstate;
+        } else {
+            c = c->fail;
+            failed = 1;
+            if (c == 0) {
+                c = w;
+istate:
+                if (ccomp(c->inp, *p)) {
+                    c = c->nst;
+                } else if (c->link != 0) {
+                    c = c->link;
+                    goto istate;
                 }
-                else goto nstate;
-            }
+            } else
+                goto nstate;
+        }
         if (c->out) {
             while (*p++ != '\n') {
                 if (--ccount <= 0) {
-                    if (p == &buf[2*blksize]) p = buf;
+                    if (p == &buf[2 * blksize])
+                        p = buf;
                     if (p > &buf[blksize]) {
-                        if ((ccount = read(f, p, &buf[2*blksize] - p)) <= 0) break;
-                    }
-                    else if ((ccount = read(f, p, blksize)) <= 0) break;
+                        if ((ccount = read(f, p, &buf[2 * blksize] - p)) <= 0)
+                            break;
+                    } else if ((ccount = read(f, p, blksize)) <= 0)
+                        break;
                     blkno += ccount;
                 }
             }
-            if ( (vflag && (failed == 0 || xflag == 0)) || (vflag == 0 && xflag && failed) )
+            if ((vflag && (failed == 0 || xflag == 0)) || (vflag == 0 && xflag && failed))
                 goto nomatch;
-    succeed:    nsucc = 1;
-            if (cflag) tln++;
+succeed:
+            nsucc = 1;
+            if (cflag)
+                tln++;
             else if (sflag)
-                ;   /* ugh */
+                ; /* ugh */
             else if (lflag) {
                 printf("%s\n", file);
                 close(f);
                 return;
-            }
-            else {
-                if (nfile > 1 && hflag) printf("%s:", file);
-                if (bflag) printf("%ld:", (blkno-ccount-1)/DEV_BSIZE);
-                if (nflag) printf("%ld:", lnum);
+            } else {
+                if (nfile > 1 && hflag)
+                    printf("%s:", file);
+                if (bflag)
+                    printf("%ld:", (blkno - ccount - 1) / DEV_BSIZE);
+                if (nflag)
+                    printf("%ld:", lnum);
                 if (p <= nlp) {
-                    while (nlp < &buf[2*blksize]) putchar(*nlp++);
+                    while (nlp < &buf[2 * blksize])
+                        putchar(*nlp++);
                     nlp = buf;
                 }
-                while (nlp < p) putchar(*nlp++);
+                while (nlp < p)
+                    putchar(*nlp++);
             }
-    nomatch:    lnum++;
+nomatch:
+            lnum++;
             nlp = p;
             c = w;
             failed = 0;
             continue;
         }
-        if (*p++ == '\n')
-            if (vflag) goto succeed;
-            else {
+        if (*p++ == '\n') {
+            if (vflag) {
+                goto succeed;
+            } else {
                 lnum++;
                 nlp = p;
                 c = w;
                 failed = 0;
             }
+        }
     }
     close(f);
     if (cflag) {
@@ -252,35 +267,40 @@ char *file;
     }
 }
 
-getargc()
+int getargc()
 {
-    register c;
+    int c;
+
     if (wordf)
-        return(getc(wordf));
+        return (getc(wordf));
     if ((c = *argptr++) == '\0')
-        return(EOF);
-    return(c);
+        return (EOF);
+    return (c);
 }
 
-cgotofn() {
-    register c;
-    register struct words *s;
+void cgotofn()
+{
+    int c;
+    struct words *s;
 
     s = smax = w;
-nword:  for(;;) {
+nword:
+    for (;;) {
         c = getargc();
-        if (c==EOF)
+        if (c == EOF)
             return;
         if (c == '\n') {
             if (xflag) {
-                for(;;) {
+                for (;;) {
                     if (s->inp == c) {
                         s = s->nst;
                         break;
                     }
-                    if (s->inp == 0) goto nenter;
+                    if (s->inp == 0)
+                        goto nenter;
                     if (s->link == 0) {
-                        if (smax >= &w[MAXSIZ -1]) overflo();
+                        if (smax >= &w[MAXSIZ - 1])
+                            overflo();
                         s->link = ++smax;
                         s = smax;
                         goto nenter;
@@ -291,13 +311,16 @@ nword:  for(;;) {
             s->out = 1;
             s = w;
         } else {
-        loop:   if (s->inp == c) {
+loop:
+            if (s->inp == c) {
                 s = s->nst;
                 continue;
             }
-            if (s->inp == 0) goto enter;
+            if (s->inp == 0)
+                goto enter;
             if (s->link == 0) {
-                if (smax >= &w[MAXSIZ - 1]) overflo();
+                if (smax >= &w[MAXSIZ - 1])
+                    overflo();
                 s->link = ++smax;
                 s = smax;
                 goto enter;
@@ -307,16 +330,19 @@ nword:  for(;;) {
         }
     }
 
-    enter:
+enter:
     do {
         s->inp = c;
-        if (smax >= &w[MAXSIZ - 1]) overflo();
+        if (smax >= &w[MAXSIZ - 1])
+            overflo();
         s->nst = ++smax;
         s = smax;
-    } while ((c = getargc()) != '\n' && c!=EOF);
+    } while ((c = getargc()) != '\n' && c != EOF);
     if (xflag) {
-    nenter: s->inp = '\n';
-        if (smax >= &w[MAXSIZ -1]) overflo();
+nenter:
+        s->inp = '\n';
+        if (smax >= &w[MAXSIZ - 1])
+            overflo();
         s->nst = ++smax;
     }
     smax->out = 1;
@@ -325,55 +351,69 @@ nword:  for(;;) {
         goto nword;
 }
 
-overflo() {
+void overflo()
+{
     fprintf(stderr, "wordlist too large\n");
     exit(2);
 }
-cfail() {
+
+void cfail()
+{
     struct words *queue[QSIZE];
     struct words **front, **rear;
     struct words *state;
     int bstart;
-    register char c;
-    register struct words *s;
+    char c;
+    struct words *s;
+
     s = w;
     front = rear = queue;
-init:   if ((s->inp) != 0) {
+init:
+    if ((s->inp) != 0) {
         *rear++ = s->nst;
-        if (rear >= &queue[QSIZE - 1]) overflo();
+        if (rear >= &queue[QSIZE - 1])
+            overflo();
     }
     if ((s = s->link) != 0) {
         goto init;
     }
 
-    while (rear!=front) {
+    while (rear != front) {
         s = *front;
-        if (front == &queue[QSIZE-1])
+        if (front == &queue[QSIZE - 1])
             front = queue;
-        else front++;
-    cloop:  if ((c = s->inp) != 0) {
+        else
+            front++;
+cloop:
+        if ((c = s->inp) != 0) {
             bstart = 0;
             *rear = (q = s->nst);
             if (front < rear)
-                if (rear >= &queue[QSIZE-1])
-                    if (front == queue) overflo();
-                    else rear = queue;
-                else rear++;
-            else
-                if (++rear == front) overflo();
+                if (rear >= &queue[QSIZE - 1])
+                    if (front == queue)
+                        overflo();
+                    else
+                        rear = queue;
+                else
+                    rear++;
+            else if (++rear == front)
+                overflo();
             state = s->fail;
-        floop:  if (state == 0) {
+floop:
+            if (state == 0) {
                 state = w;
                 bstart = 1;
             }
             if (state->inp == c) {
-            qloop:  q->fail = state->nst;
-                if ((state->nst)->out == 1) q->out = 1;
-                if ((q = q->link) != 0) goto qloop;
-            }
-            else if ((state = state->link) != 0)
+qloop:
+                q->fail = state->nst;
+                if ((state->nst)->out == 1)
+                    q->out = 1;
+                if ((q = q->link) != 0)
+                    goto qloop;
+            } else if ((state = state->link) != 0)
                 goto floop;
-            else if(bstart == 0){
+            else if (bstart == 0) {
                 state = 0;
                 goto floop;
             }
diff --git a/src/cmd/file.c b/src/cmd/file.c
index eb2311a..dd74b59 100644
--- a/src/cmd/file.c
+++ b/src/cmd/file.c
@@ -1,42 +1,46 @@
 /*
  * file - determine type of file
  */
-#include <sys/param.h>
-#include <sys/stat.h>
+#include <a.out.h>
+#include <ctype.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
-#include <a.out.h>
-#include <errno.h>
 #include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/stat.h>
 
 int in;
-int i  = 0;
+int i = 0;
 char buf[BUFSIZ];
-char *troff[] = {   /* new troff intermediate lang */
-    "x","T","res","init","font","202","V0","p1",0};
-char *fort[] = {
-    "function","subroutine","common","dimension","block","integer",
-    "real","data","double",0};
-char *asc[] = {
-    "sys","mov","tst","clr","jmp",0};
-char *c[] = {
-    "int","char","float","double","struct","extern",0};
-char *as[] = {
-    "globl","byte","align","text","data","comm",0};
-char *sh[] = {
-    "fi", "elif", "esac", "done", "export",
-    "readonly", "trap", "PATH", "HOME", 0 };
-char *csh[] = {
-    "alias", "breaksw", "endsw", "foreach", "limit",  "onintr",
-    "repeat", "setenv", "source", "path", "home", 0 };
+char *troff[] = { /* new troff intermediate lang */
+                  "x", "T", "res", "init", "font", "202", "V0", "p1", 0
+};
+char *fort[] = { "function", "subroutine", "common", "dimension", "block",
+                 "integer",  "real",       "data",   "double",    0 };
+char *asc[] = { "sys", "mov", "tst", "clr", "jmp", 0 };
+char *c[] = { "int", "char", "float", "double", "struct", "extern", 0 };
+char *as[] = { "globl", "byte", "align", "text", "data", "comm", 0 };
+char *sh[] = { "fi", "elif", "esac", "done", "export", "readonly", "trap", "PATH", "HOME", 0 };
+char *csh[] = { "alias",  "breaksw", "endsw",  "foreach", "limit", "onintr",
+                "repeat", "setenv",  "source", "path",    "home",  0 };
 int ifile;
 
-main(argc, argv)
-char **argv;
+static void type(char *file);
+static int shellscript(char buf[], struct stat *sb);
+static int ccom(void);
+static int lookup(char *tab[]);
+static int ascom(void);
+static int shell(char *bp, int n, char *tab[]);
+static int troffint(char *bp, int n);
+static int english(char *bp, int n);
+
+int main(int argc, char **argv)
 {
-    register FILE *fl;
-    register char *p;
+    FILE *fl;
+    char *p;
     char ap[MAXPATHLEN + 1];
 
     if (argc < 2) {
@@ -44,23 +48,23 @@ char **argv;
         exit(3);
     }
 
-    if (argc>1 && argv[1][0]=='-' && argv[1][1]=='f') {
+    if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'f') {
         if ((fl = fopen(argv[2], "r")) == NULL) {
             perror(argv[2]);
             exit(2);
         }
         while ((p = fgets(ap, sizeof ap, fl)) != NULL) {
             int l = strlen(p);
-            if (l>0)
-                p[l-1] = '\0';
+            if (l > 0)
+                p[l - 1] = '\0';
             printf("%s: ", p);
             type(p);
-            if (ifile>=0)
+            if (ifile >= 0)
                 close(ifile);
         }
         exit(1);
     }
-    while(argc > 1) {
+    while (argc > 1) {
         printf("%s: ", argv[1]);
         type(argv[1]);
         fflush(stdout);
@@ -72,10 +76,9 @@ char **argv;
     exit(0);
 }
 
-type(file)
-char *file;
+void type(char *file)
 {
-    register int j;
+    int j;
     int nl;
     char ch;
     struct stat mbuf;
@@ -87,7 +90,6 @@ char *file;
         return;
     }
     switch (mbuf.st_mode & S_IFMT) {
-
     case S_IFLNK:
         printf("symbolic link");
         j = readlink(file, slink, sizeof slink - 1);
@@ -106,9 +108,8 @@ char *file;
 
     case S_IFCHR:
     case S_IFBLK:
-        printf("%s special (%d/%d)\n",
-            (mbuf.st_mode&S_IFMT) == S_IFCHR ? "character" : "block",
-             major(mbuf.st_rdev), minor(mbuf.st_rdev));
+        printf("%s special (%d/%d)\n", (mbuf.st_mode & S_IFMT) == S_IFCHR ? "character" : "block",
+               major(mbuf.st_rdev), minor(mbuf.st_rdev));
         return;
 
     case S_IFSOCK:
@@ -117,17 +118,16 @@ char *file;
     }
 
     ifile = open(file, 0);
-    if(ifile < 0) {
+    if (ifile < 0) {
         printf("%s\n", strerror(errno));
         return;
     }
     in = read(ifile, buf, BUFSIZ);
-    if(in == 0){
+    if (in == 0) {
         printf("empty\n");
         return;
     }
-    switch(*(int *)buf) {
-
+    switch (*(int *)buf) {
     case 0413:
         printf("demand paged ");
 
@@ -140,7 +140,7 @@ char *file;
         goto exec;
 
     case 0407:
-exec:
+    exec:
         if (mbuf.st_mode & S_ISUID)
             printf("set-uid ");
         if (mbuf.st_mode & S_ISGID)
@@ -148,10 +148,9 @@ exec:
         if (mbuf.st_mode & S_ISVTX)
             printf("sticky ");
         printf("executable");
-        if(((int *)buf)[4] != 0)
+        if (((int *)buf)[4] != 0)
             printf(" not stripped");
-        if (((int *)buf)[1] == 0 && ((int *)buf)[2] != 0 &&
-            ((int *)buf)[3] == 0)
+        if (((int *)buf)[1] == 0 && ((int *)buf)[2] != 0 && ((int *)buf)[3] == 0)
             printf(" (likely vax)");
         printf("\n");
         return;
@@ -169,109 +168,125 @@ exec:
         return;
     }
 
-    if (buf[0] == '#' && buf[1] == '!' && shellscript(buf+2, &mbuf))
+    if (buf[0] == '#' && buf[1] == '!' && shellscript(buf + 2, &mbuf))
         return;
     if (buf[0] == '\037' && buf[1] == '\235') {
-        if (buf[2]&0x80)
+        if (buf[2] & 0x80)
             printf("block ");
-        printf("compressed %d bit code data\n", buf[2]&0x1f);
+        printf("compressed %d bit code data\n", buf[2] & 0x1f);
         return;
     }
-    if(strncmp(buf, "!<arch>\n__.SYMDEF", 17) == 0 ) {
+    if (strncmp(buf, "!<arch>\n__.SYMDEF", 17) == 0) {
         printf("archive random library\n");
         return;
     }
-    if (strncmp(buf, "!<arch>\n", 8)==0) {
+    if (strncmp(buf, "!<arch>\n", 8) == 0) {
         printf("archive\n");
         return;
     }
-    if (mbuf.st_size % 512 == 0) {  /* it may be a PRESS file */
-        lseek(ifile, -512L, 2); /* last block */
+    if (mbuf.st_size % 512 == 0) { /* it may be a PRESS file */
+        lseek(ifile, -512L, 2);    /* last block */
         if (read(ifile, buf, BUFSIZ) > 0 && *(short *)buf == 12138) {
             printf("PRESS file\n");
             return;
         }
     }
     i = 0;
-    if(ccom() == 0)goto notc;
-    while(buf[i] == '#'){
+    if (ccom() == 0)
+        goto notc;
+    while (buf[i] == '#') {
         j = i;
-        while(buf[i++] != '\n'){
-            if(i - j > 255){
+        while (buf[i++] != '\n') {
+            if (i - j > 255) {
                 printf("data\n");
                 return;
             }
-            if(i >= in)goto notc;
+            if (i >= in)
+                goto notc;
         }
-        if(ccom() == 0)goto notc;
+        if (ccom() == 0)
+            goto notc;
     }
 check:
-    if(lookup(c) == 1){
-        while((ch = buf[i++]) != ';' && ch != '{')if(i >= in)goto notc;
+    if (lookup(c) == 1) {
+        while ((ch = buf[i++]) != ';' && ch != '{')
+            if (i >= in)
+                goto notc;
         printf("c program text");
         goto outa;
     }
     nl = 0;
-    while(buf[i] != '('){
-        if(buf[i] <= 0)
+    while (buf[i] != '(') {
+        if (buf[i] <= 0)
             goto notas;
-        if(buf[i] == ';'){
+        if (buf[i] == ';') {
             i++;
             goto check;
         }
-        if(buf[i++] == '\n')
-            if(nl++ > 6)goto notc;
-        if(i >= in)goto notc;
+        if (buf[i++] == '\n')
+            if (nl++ > 6)
+                goto notc;
+        if (i >= in)
+            goto notc;
     }
-    while(buf[i] != ')'){
-        if(buf[i++] == '\n')
-            if(nl++ > 6)goto notc;
-        if(i >= in)goto notc;
+    while (buf[i] != ')') {
+        if (buf[i++] == '\n')
+            if (nl++ > 6)
+                goto notc;
+        if (i >= in)
+            goto notc;
     }
-    while(buf[i] != '{'){
-        if(buf[i++] == '\n')
-            if(nl++ > 6)goto notc;
-        if(i >= in)goto notc;
+    while (buf[i] != '{') {
+        if (buf[i++] == '\n')
+            if (nl++ > 6)
+                goto notc;
+        if (i >= in)
+            goto notc;
     }
     printf("c program text");
     goto outa;
 notc:
     i = 0;
-    while(buf[i] == 'c' || buf[i] == '#'){
-        while(buf[i++] != '\n')if(i >= in)goto notfort;
+    while (buf[i] == 'c' || buf[i] == '#') {
+        while (buf[i++] != '\n')
+            if (i >= in)
+                goto notfort;
     }
-    if(lookup(fort) == 1){
+    if (lookup(fort) == 1) {
         printf("fortran program text");
         goto outa;
     }
 notfort:
-    i=0;
-    if(ascom() == 0)goto notas;
-    j = i-1;
-    if(buf[i] == '.'){
+    i = 0;
+    if (ascom() == 0)
+        goto notas;
+    j = i - 1;
+    if (buf[i] == '.') {
         i++;
-        if(lookup(as) == 1){
+        if (lookup(as) == 1) {
             printf("assembler program text");
             goto outa;
-        }
-        else if(buf[j] == '\n' && isalpha(buf[j+2])){
+        } else if (buf[j] == '\n' && isalpha(buf[j + 2])) {
             printf("roff, nroff, or eqn input text");
             goto outa;
         }
     }
-    while(lookup(asc) == 0){
-        if(ascom() == 0)goto notas;
-        while(buf[i] != '\n' && buf[i++] != ':')
-            if(i >= in)goto notas;
-        while(buf[i] == '\n' || buf[i] == ' ' || buf[i] == '\t')if(i++ >= in)goto notas;
-        j = i-1;
-        if(buf[i] == '.'){
+    while (lookup(asc) == 0) {
+        if (ascom() == 0)
+            goto notas;
+        while (buf[i] != '\n' && buf[i++] != ':')
+            if (i >= in)
+                goto notas;
+        while (buf[i] == '\n' || buf[i] == ' ' || buf[i] == '\t')
+            if (i++ >= in)
+                goto notas;
+        j = i - 1;
+        if (buf[i] == '.') {
             i++;
-            if(lookup(as) == 1){
+            if (lookup(as) == 1) {
                 printf("assembler program text");
                 goto outa;
-            }
-            else if(buf[j] == '\n' && isalpha(buf[j+2])){
+            } else if (buf[j] == '\n' && isalpha(buf[j + 2])) {
                 printf("roff, nroff, or eqn input text");
                 goto outa;
             }
@@ -280,14 +295,15 @@ notfort:
     printf("assembler program text");
     goto outa;
 notas:
-    for(i=0; i < in; i++)if(buf[i]&0200){
-        if (buf[0]=='\100' && buf[1]=='\357')
-            printf("troff (CAT) output\n");
-        else
-            printf("data\n");
-        return;
-    }
-    if (mbuf.st_mode&((S_IEXEC)|(S_IEXEC>>3)|(S_IEXEC>>6))) {
+    for (i = 0; i < in; i++)
+        if (buf[i] & 0200) {
+            if (buf[0] == '\100' && buf[1] == '\357')
+                printf("troff (CAT) output\n");
+            else
+                printf("data\n");
+            return;
+        }
+    if (mbuf.st_mode & ((S_IEXEC) | (S_IEXEC >> 3) | (S_IEXEC >> 6))) {
         if (mbuf.st_mode & S_ISUID)
             printf("set-uid ");
         if (mbuf.st_mode & S_ISGID)
@@ -311,103 +327,117 @@ notas:
     else
         printf("ascii text");
 outa:
-    while(i < in)
-        if((buf[i++]&0377) > 127){
+    while (i < in) {
+        if ((buf[i++] & 0377) > 127) {
             printf(" with garbage\n");
             return;
         }
-    /* if next few lines in then read whole file looking for nulls ...
-        while((in = read(ifile,buf,BUFSIZ)) > 0)
-            for(i = 0; i < in; i++)
-                if((buf[i]&0377) > 127){
-                    printf(" with garbage\n");
-                    return;
-                }
-        /*.... */
+    }
+#if 0
+    /* if next few lines in then read whole file looking for nulls... */
+    while ((in = read(ifile,buf,BUFSIZ)) > 0) {
+        for (i = 0; i < in; i++) {
+            if ((buf[i]&0377) > 127) {
+                printf(" with garbage\n");
+                return;
+            }
+        }
+    }
+#endif
     printf("\n");
 }
 
-troffint(bp, n)
-char *bp;
-int n;
+int troffint(char *bp, int n)
 {
     int k;
 
     i = 0;
     for (k = 0; k < 6; k++) {
         if (lookup(troff) == 0)
-            return(0);
+            return (0);
         if (lookup(troff) == 0)
-            return(0);
+            return (0);
         while (i < n && buf[i] != '\n')
             i++;
         if (i++ >= n)
-            return(0);
+            return (0);
     }
-    return(1);
+    return (1);
 }
 
-lookup(tab)
-char *tab[];
+int lookup(char *tab[])
 {
     char r;
-    int k,j,l;
-    while(buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\n')i++;
-    for(j=0; tab[j] != 0; j++){
-        l=0;
-        for(k=i; ((r=tab[j][l++]) == buf[k] && r != '\0');k++);
-        if(r == '\0')
-            if(buf[k] == ' ' || buf[k] == '\n' || buf[k] == '\t'
-                || buf[k] == '{' || buf[k] == '/'){
-                i=k;
-                return(1);
+    int k, j, l;
+    while (buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\n')
+        i++;
+    for (j = 0; tab[j] != 0; j++) {
+        l = 0;
+        for (k = i; ((r = tab[j][l++]) == buf[k] && r != '\0'); k++)
+            ;
+        if (r == '\0')
+            if (buf[k] == ' ' || buf[k] == '\n' || buf[k] == '\t' || buf[k] == '{' ||
+                buf[k] == '/') {
+                i = k;
+                return (1);
             }
     }
-    return(0);
+    return (0);
 }
 
-ccom()
+int ccom()
 {
     char cc;
-    while((cc = buf[i]) == ' ' || cc == '\t' || cc == '\n')if(i++ >= in)return(0);
-    if(buf[i] == '/' && buf[i+1] == '*'){
+    while ((cc = buf[i]) == ' ' || cc == '\t' || cc == '\n')
+        if (i++ >= in)
+            return (0);
+    if (buf[i] == '/' && buf[i + 1] == '*') {
         i += 2;
-        while(buf[i] != '*' || buf[i+1] != '/'){
-            if(buf[i] == '\\')i += 2;
-            else i++;
-            if(i >= in)return(0);
+        while (buf[i] != '*' || buf[i + 1] != '/') {
+            if (buf[i] == '\\')
+                i += 2;
+            else
+                i++;
+            if (i >= in)
+                return (0);
         }
-        if((i += 2) >= in)return(0);
+        if ((i += 2) >= in)
+            return (0);
     }
-    if(buf[i] == '\n')if(ccom() == 0)return(0);
-    return(1);
+    if (buf[i] == '\n')
+        if (ccom() == 0)
+            return (0);
+    return (1);
 }
 
-ascom()
+int ascom()
 {
-    while(buf[i] == '/'){
+    while (buf[i] == '/') {
         i++;
-        while(buf[i++] != '\n')if(i >= in)return(0);
-        while(buf[i] == '\n')if(i++ >= in)return(0);
+        while (buf[i++] != '\n')
+            if (i >= in)
+                return (0);
+        while (buf[i] == '\n')
+            if (i++ >= in)
+                return (0);
     }
-    return(1);
+    return (1);
 }
 
-english (bp, n)
-char *bp;
+int english(char *bp, int n)
 {
 #define NASC 128
     int ct[NASC], j, vow, freq, rare;
     int badpun = 0, punct = 0;
-    if (n<50) return(0); /* no point in statistics on squibs */
-    for(j=0; j<NASC; j++)
-        ct[j]=0;
-    for(j=0; j<n; j++)
-    {
-        if (bp[j]<NASC)
-            ct[bp[j]|040]++;
-        switch (bp[j])
-        {
+    if (n < 50)
+        return (0); /* no point in statistics on squibs */
+    for (j = 0; j < NASC; j++)
+        ct[j] = 0;
+    for (j = 0; j < n; j++) {
+        unsigned c = bp[j];
+        if (c < NASC)
+            ct[c | 040]++;
+        switch (c) {
         case '.':
         case ',':
         case ')':
@@ -416,27 +446,25 @@ char *bp;
         case ':':
         case '?':
             punct++;
-            if ( j < n-1 &&
-                bp[j+1] != ' ' &&
-                bp[j+1] != '\n')
+            if (j < n - 1 && bp[j + 1] != ' ' && bp[j + 1] != '\n')
                 badpun++;
         }
     }
-    if (badpun*5 > punct)
-        return(0);
+    if (badpun * 5 > punct)
+        return (0);
     vow = ct['a'] + ct['e'] + ct['i'] + ct['o'] + ct['u'];
     freq = ct['e'] + ct['t'] + ct['a'] + ct['i'] + ct['o'] + ct['n'];
     rare = ct['v'] + ct['j'] + ct['k'] + ct['q'] + ct['x'] + ct['z'];
-    if (2*ct[';'] > ct['e']) return(0);
-    if ( (ct['>']+ct['<']+ct['/'])>ct['e']) return(0); /* shell file test */
-    return (vow*5 >= n-ct[' '] && freq >= 10*rare);
+    if (2 * ct[';'] > ct['e'])
+        return (0);
+    if ((ct['>'] + ct['<'] + ct['/']) > ct['e'])
+        return (0); /* shell file test */
+    return (vow * 5 >= n - ct[' '] && freq >= 10 * rare);
 }
 
-shellscript(buf, sb)
-    char buf[];
-    struct stat *sb;
+int shellscript(char buf[], struct stat *sb)
 {
-    register char *tp;
+    char *tp;
     char *cp, *xp, *index();
 
     cp = index(buf, '\n');
@@ -454,9 +482,9 @@ shellscript(buf, sb)
         printf("set-uid ");
     if (sb->st_mode & S_ISGID)
         printf("set-gid ");
-    if (strncmp(xp, "/bin/sh", tp-xp) == 0)
+    if (strncmp(xp, "/bin/sh", tp - xp) == 0)
         xp = "shell";
-    else if (strncmp(xp, "/bin/csh", tp-xp) == 0)
+    else if (strncmp(xp, "/bin/csh", tp - xp) == 0)
         xp = "c-shell";
     else
         *tp = '\0';
@@ -464,12 +492,8 @@ shellscript(buf, sb)
     return (1);
 }
 
-shell(bp, n, tab)
-    char *bp;
-    int n;
-    char *tab[];
+int shell(char *bp, int n, char *tab[])
 {
-
     i = 0;
     do {
         if (buf[i] == '#' || buf[i] == ':')
diff --git a/src/cmd/grep.c b/src/cmd/grep.c
index d0cfec4..53dbedb 100644
--- a/src/cmd/grep.c
+++ b/src/cmd/grep.c
@@ -6,66 +6,62 @@
  *      1 - ok, but no matches
  *      2 - some error
  */
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
 
-#define CBRA    1
-#define CCHR    2
-#define CDOT    4
+#define CBRA 1
+#define CCHR 2
+#define CDOT 4
 #define CCL 6
-#define NCCL    8
-#define CDOL    10
-#define CEOF    11
-#define CKET    12
-#define CBRC    14
-#define CLET    15
-#define CBACK   18
+#define NCCL 8
+#define CDOL 10
+#define CEOF 11
+#define CKET 12
+#define CBRC 14
+#define CLET 15
+#define CBACK 18
 
-#define STAR    01
+#define STAR 01
 
-#define LBSIZE  BUFSIZ
-#define ESIZE   256
-#define NBRA    9
+#define LBSIZE BUFSIZ
+#define ESIZE 256
+#define NBRA 9
 
-char    expbuf[ESIZE];
-long    lnum;
-char    linebuf[LBSIZE+1];
-char    ybuf[ESIZE];
+char expbuf[ESIZE];
+long lnum;
+char linebuf[LBSIZE + 1];
+char ybuf[ESIZE];
 int bflag;
 int lflag;
 int nflag;
 int cflag;
 int vflag;
 int nfile;
-int hflag   = 1;
+int hflag = 1;
 int sflag;
 int yflag;
 int wflag;
 int retcode = 0;
 int circf;
 int blkno;
-long    tln;
+long tln;
 int nsucc;
-char    *braslist[NBRA];
-char    *braelist[NBRA];
-char    bittab[] = {
-    1,
-    2,
-    4,
-    8,
-    16,
-    32,
-    64,
-    128
-};
+char *braslist[NBRA];
+char *braelist[NBRA];
+char bittab[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
 
-main(argc, argv)
-char **argv;
+static void errexit(char *s, char *f);
+static void compile(char *astr);
+static void execute(char *file);
+static int advance(char *lp, char *ep);
+static void succeed(char *f);
+static int ecmp(char *a, char *b, int count);
+
+int main(int argc, char **argv)
 {
-    while (--argc > 0 && (++argv)[0][0]=='-')
+    while (--argc > 0 && (++argv)[0][0] == '-')
         switch (argv[0][1]) {
-
         case 'i':
         case 'y':
             yflag++;
@@ -113,11 +109,11 @@ char **argv;
             continue;
         }
 out:
-    if (argc<=0)
+    if (argc <= 0)
         exit(2);
     if (yflag) {
-        register char *p, *s;
-        for (s = ybuf, p = *argv; *p; ) {
+        char *p, *s;
+        for (s = ybuf, p = *argv; *p;) {
             if (*p == '\\') {
                 *s++ = *p++;
                 if (*p)
@@ -132,7 +128,7 @@ out:
                 *s++ = ']';
             } else
                 *s++ = *p++;
-            if (s >= ybuf+ESIZE-5)
+            if (s >= ybuf + ESIZE - 5)
                 errexit("grep: argument too long\n", (char *)NULL);
         }
         *s = '\0';
@@ -140,22 +136,22 @@ out:
     }
     compile(*argv);
     nfile = --argc;
-    if (argc<=0) {
+    if (argc <= 0) {
         if (lflag)
             exit(1);
         execute((char *)NULL);
-    } else while (--argc >= 0) {
-        argv++;
-        execute(*argv);
-    }
+    } else
+        while (--argc >= 0) {
+            argv++;
+            execute(*argv);
+        }
     exit(retcode != 0 ? retcode : nsucc == 0);
 }
 
-compile(astr)
-char *astr;
+void compile(char *astr)
 {
-    register c;
-    register char *ep, *sp;
+    int c;
+    char *ep, *sp;
     char *cstart;
     char *lastep;
     int cclcnt;
@@ -181,7 +177,6 @@ char *astr;
         if ((c = *sp++) != '*')
             lastep = ep;
         switch (c) {
-
         case '\0':
             if (wflag)
                 *ep++ = CLET;
@@ -193,8 +188,8 @@ char *astr;
             continue;
 
         case '*':
-            if (lastep==0 || *lastep==CBRA || *lastep==CKET ||
-                *lastep == CBRC || *lastep == CLET)
+            if (lastep == 0 || *lastep == CBRA || *lastep == CKET || *lastep == CBRC ||
+                *lastep == CLET)
                 goto defchar;
             *lastep |= STAR;
             continue;
@@ -206,27 +201,27 @@ char *astr;
             continue;
 
         case '[':
-            if(&ep[17] >= &expbuf[ESIZE])
+            if (&ep[17] >= &expbuf[ESIZE])
                 goto cerror;
             *ep++ = CCL;
             neg = 0;
-            if((c = *sp++) == '^') {
+            if ((c = *sp++) == '^') {
                 neg = 1;
                 c = *sp++;
             }
             cstart = sp;
             do {
-                if (c=='\0')
+                if (c == '\0')
                     goto cerror;
-                if (c=='-' && sp>cstart && *sp!=']') {
-                    for (c = sp[-2]; c<*sp; c++)
-                        ep[c>>3] |= bittab[c&07];
+                if (c == '-' && sp > cstart && *sp != ']') {
+                    for (c = sp[-2]; c < *sp; c++)
+                        ep[c >> 3] |= bittab[c & 07];
                     sp++;
                 }
-                ep[c>>3] |= bittab[c&07];
-            } while((c = *sp++) != ']');
-            if(neg) {
-                for(cclcnt = 0; cclcnt < 16; cclcnt++)
+                ep[c >> 3] |= bittab[c & 07];
+            } while ((c = *sp++) != ']');
+            if (neg) {
+                for (cclcnt = 0; cclcnt < 16; cclcnt++)
                     ep[cclcnt] ^= -1;
                 ep[0] &= 0376;
             }
@@ -236,18 +231,18 @@ char *astr;
             continue;
 
         case '\\':
-            if((c = *sp++) == 0)
+            if ((c = *sp++) == 0)
                 goto cerror;
-            if(c == '<') {
+            if (c == '<') {
                 *ep++ = CBRC;
                 continue;
             }
-            if(c == '>') {
+            if (c == '>') {
                 *ep++ = CLET;
                 continue;
             }
-            if(c == '(') {
-                if(numbra >= NBRA) {
+            if (c == '(') {
+                if (numbra >= NBRA) {
                     goto cerror;
                 }
                 *bracketp++ = numbra;
@@ -255,8 +250,8 @@ char *astr;
                 *ep++ = numbra++;
                 continue;
             }
-            if(c == ')') {
-                if(bracketp <= bracket) {
+            if (c == ')') {
+                if (bracketp <= bracket) {
                     goto cerror;
                 }
                 *ep++ = CKET;
@@ -265,8 +260,8 @@ char *astr;
                 continue;
             }
 
-            if(c >= '1' && c <= '9') {
-                if((c -= '1') >= closed)
+            if (c >= '1' && c <= '9') {
+                if ((c -= '1') >= closed)
                     goto cerror;
                 *ep++ = CBACK;
                 *ep++ = c;
@@ -279,15 +274,14 @@ char *astr;
             *ep++ = c;
         }
     }
-    cerror:
+cerror:
     errexit("grep: RE error\n", (char *)NULL);
 }
 
-execute(file)
-char *file;
+void execute(char *file)
 {
-    register char *p1, *p2;
-    register c;
+    char *p1, *p2;
+    int c;
 
     if (file) {
         if (freopen(file, "r", stdin) == NULL) {
@@ -303,15 +297,15 @@ char *file;
         while ((c = getchar()) != '\n') {
             if (c == EOF) {
                 if (cflag) {
-                    if (nfile>1)
+                    if (nfile > 1)
                         printf("%s:", file);
-                    printf("%D\n", tln);
+                    printf("%ld\n", tln);
                     fflush(stdout);
                 }
                 return;
             }
             *p1++ = c;
-            if (p1 >= &linebuf[LBSIZE-1])
+            if (p1 >= &linebuf[LBSIZE - 1])
                 break;
         }
         *p1++ = '\0';
@@ -323,10 +317,10 @@ char *file;
             goto nfound;
         }
         /* fast check for first character */
-        if (*p2==CCHR) {
+        if (*p2 == CCHR) {
             c = p2[1];
             do {
-                if (*p1!=c)
+                if (*p1 != c)
                     continue;
                 if (advance(p1, p2))
                     goto found;
@@ -343,142 +337,142 @@ char *file;
             succeed(file);
         continue;
     found:
-        if (vflag==0)
+        if (vflag == 0)
             succeed(file);
     }
 }
 
-advance(lp, ep)
-register char *lp, *ep;
+int advance(char *lp, char *ep)
 {
-    register char *curlp;
+    char *curlp;
     char c;
     char *bbeg;
     int ct;
 
-    for (;;) switch (*ep++) {
-
-    case CCHR:
-        if (*ep++ == *lp++)
-            continue;
-        return(0);
-
-    case CDOT:
-        if (*lp++)
-            continue;
-        return(0);
-
-    case CDOL:
-        if (*lp==0)
-            continue;
-        return(0);
-
-    case CEOF:
-        return(1);
-
-    case CCL:
-        c = *lp++ & 0177;
-        if(ep[c>>3] & bittab[c & 07]) {
-            ep += 16;
-            continue;
-        }
-        return(0);
-    case CBRA:
-        braslist[*ep++] = lp;
-        continue;
-
-    case CKET:
-        braelist[*ep++] = lp;
-        continue;
-
-    case CBACK:
-        bbeg = braslist[*ep];
-        if (braelist[*ep]==0)
-            return(0);
-        ct = braelist[*ep++] - bbeg;
-        if(ecmp(bbeg, lp, ct)) {
-            lp += ct;
-            continue;
-        }
-        return(0);
-
-    case CBACK|STAR:
-        bbeg = braslist[*ep];
-        if (braelist[*ep]==0)
-            return(0);
-        ct = braelist[*ep++] - bbeg;
-        curlp = lp;
-        while(ecmp(bbeg, lp, ct))
-            lp += ct;
-        while(lp >= curlp) {
-            if(advance(lp, ep)) return(1);
-            lp -= ct;
-        }
-        return(0);
-
-
-    case CDOT|STAR:
-        curlp = lp;
-        while (*lp++);
-        goto star;
-
-    case CCHR|STAR:
-        curlp = lp;
-        while (*lp++ == *ep);
-        ep++;
-        goto star;
-
-    case CCL|STAR:
-        curlp = lp;
-        do {
-            c = *lp++ & 0177;
-        } while(ep[c>>3] & bittab[c & 07]);
-        ep += 16;
-        goto star;
-
-    star:
-        if(--lp == curlp) {
-            continue;
-        }
-
-        if(*ep == CCHR) {
-            c = ep[1];
-            do {
-                if(*lp != c)
-                    continue;
-                if(advance(lp, ep))
-                    return(1);
-            } while(lp-- > curlp);
-            return(0);
-        }
-
-        do {
-            if (advance(lp, ep))
-                return(1);
-        } while (lp-- > curlp);
-        return(0);
-
-    case CBRC:
-        if (lp == expbuf)
-            continue;
-#define uletter(c)  (isalpha(c) || (c) == '_')
-        if (uletter(*lp) || isdigit(*lp))
-            if (!uletter(lp[-1]) && !isdigit(lp[-1]))
+    for (;;)
+        switch (*ep++) {
+        case CCHR:
+            if (*ep++ == *lp++)
                 continue;
-        return (0);
+            return (0);
 
-    case CLET:
-        if (!uletter(*lp) && !isdigit(*lp))
+        case CDOT:
+            if (*lp++)
+                continue;
+            return (0);
+
+        case CDOL:
+            if (*lp == 0)
+                continue;
+            return (0);
+
+        case CEOF:
+            return (1);
+
+        case CCL:
+            c = *lp++ & 0177;
+            if (ep[c >> 3] & bittab[c & 07]) {
+                ep += 16;
+                continue;
+            }
+            return (0);
+        case CBRA:
+            braslist[*ep++] = lp;
             continue;
-        return (0);
 
-    default:
-        errexit("grep RE botch\n", (char *)NULL);
-    }
+        case CKET:
+            braelist[*ep++] = lp;
+            continue;
+
+        case CBACK:
+            bbeg = braslist[*ep];
+            if (braelist[*ep] == 0)
+                return (0);
+            ct = braelist[*ep++] - bbeg;
+            if (ecmp(bbeg, lp, ct)) {
+                lp += ct;
+                continue;
+            }
+            return (0);
+
+        case CBACK | STAR:
+            bbeg = braslist[*ep];
+            if (braelist[*ep] == 0)
+                return (0);
+            ct = braelist[*ep++] - bbeg;
+            curlp = lp;
+            while (ecmp(bbeg, lp, ct))
+                lp += ct;
+            while (lp >= curlp) {
+                if (advance(lp, ep))
+                    return (1);
+                lp -= ct;
+            }
+            return (0);
+
+        case CDOT | STAR:
+            curlp = lp;
+            while (*lp++)
+                ;
+            goto star;
+
+        case CCHR | STAR:
+            curlp = lp;
+            while (*lp++ == *ep)
+                ;
+            ep++;
+            goto star;
+
+        case CCL | STAR:
+            curlp = lp;
+            do {
+                c = *lp++ & 0177;
+            } while (ep[c >> 3] & bittab[c & 07]);
+            ep += 16;
+            goto star;
+
+        star:
+            if (--lp == curlp) {
+                continue;
+            }
+
+            if (*ep == CCHR) {
+                c = ep[1];
+                do {
+                    if (*lp != c)
+                        continue;
+                    if (advance(lp, ep))
+                        return (1);
+                } while (lp-- > curlp);
+                return (0);
+            }
+
+            do {
+                if (advance(lp, ep))
+                    return (1);
+            } while (lp-- > curlp);
+            return (0);
+
+        case CBRC:
+            if (lp == expbuf)
+                continue;
+#define uletter(c) (isalpha(c) || (c) == '_')
+            if (uletter(*lp) || isdigit(*lp))
+                if (!uletter(lp[-1]) && !isdigit(lp[-1]))
+                    continue;
+            return (0);
+
+        case CLET:
+            if (!uletter(*lp) && !isdigit(*lp))
+                continue;
+            return (0);
+
+        default:
+            errexit("grep RE botch\n", (char *)NULL);
+        }
 }
 
-succeed(f)
-char *f;
+void succeed(char *f)
 {
     nsucc = 1;
     if (sflag)
@@ -503,17 +497,17 @@ char *f;
     fflush(stdout);
 }
 
-ecmp(a, b, count)
-char    *a, *b;
+int ecmp(char *a, char *b, int count)
 {
-    register cc = count;
-    while(cc--)
-        if(*a++ != *b++)    return(0);
-    return(1);
+    int cc = count;
+
+    while (cc--)
+        if (*a++ != *b++)
+            return (0);
+    return (1);
 }
 
-errexit(s, f)
-char *s, *f;
+void errexit(char *s, char *f)
 {
     fprintf(stderr, s, f);
     exit(2);
diff --git a/src/cmd/head.c b/src/cmd/head.c
index 4d72647..ac55e56 100644
--- a/src/cmd/head.c
+++ b/src/cmd/head.c
@@ -9,18 +9,18 @@
  */
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
-int linecnt = 10;
-int argc;
+static int getnum(char *cp);
+static void copyout(int cnt);
 
-main(Argc, argv)
-    int Argc;
-    char *argv[];
+int main(int Argc, char *argv[])
 {
-    register int argc;
+    int argc;
     char *name;
-    register char *argp;
-    static int around;
+    char *argp;
+    int linecnt = 10;
+    int around = 0;
 
     Argc--, argv++;
     argc = Argc;
@@ -51,10 +51,9 @@ main(Argc, argv)
     } while (argc > 0);
 }
 
-copyout(cnt)
-    register int cnt;
+void copyout(int cnt)
 {
-    register int c;
+    int c;
     char lbuf[BUFSIZ];
 
     while (cnt > 0 && fgets(lbuf, sizeof lbuf, stdin) != 0) {
@@ -64,10 +63,9 @@ copyout(cnt)
     }
 }
 
-getnum(cp)
-    register char *cp;
+int getnum(char *cp)
 {
-    register int i;
+    int i;
 
     for (i = 0; *cp >= '0' && *cp <= '9'; cp++)
         i *= 10, i += *cp - '0';
diff --git a/src/cmd/hostid.c b/src/cmd/hostid.c
index 372e4b1..e09a483 100644
--- a/src/cmd/hostid.c
+++ b/src/cmd/hostid.c
@@ -3,23 +3,24 @@
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  */
-#include <sys/types.h>
+#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
 #include <string.h>
 #include <strings.h>
+#include <sys/types.h>
 #include <unistd.h>
-#if HAVE_NET
-#include <netdb.h>
 #include <arpa/inet.h>
-#endif
 
-main(argc, argv)
-    int argc;
-    char **argv;
+void usage()
 {
-    register char *id;
+    errx(1, "usage: [hexnum or internet name/address]");
+    /* NOTREACHED */
+}
+
+int main(int argc, char **argv)
+{
+    char *id;
     u_long addr;
     long hostid;
     struct hostent *hp;
@@ -36,7 +37,7 @@ main(argc, argv)
         hostid = addr;
     } else
 #endif
-    if (index(id, '.')) {
+        if (index(id, '.')) {
         if ((hostid = inet_addr(id)) == -1L)
             usage();
     } else {
@@ -50,9 +51,3 @@ main(argc, argv)
         err(1, "sethostid");
     exit(0);
 }
-
-usage()
-{
-    errx (1,"usage: [hexnum or internet name/address]");
-/* NOTREACHED */
-}
diff --git a/src/cmd/join.c b/src/cmd/join.c
index d38cc94..b1c3039 100644
--- a/src/cmd/join.c
+++ b/src/cmd/join.c
@@ -3,30 +3,36 @@
  */
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
 
-#define F1      0
-#define F2      1
-#define NFLD    20  /* max field per line */
-#define comp()  cmp(ppi[F1][fj1],ppi[F2][fj2])
+#define F1 0
+#define F2 1
+#define NFLD 20 /* max field per line */
+#define comp() cmp(ppi[F1][fj1], ppi[F2][fj2])
 
 FILE *f[2];
-char buf[2][BUFSIZ];    /*input lines */
-char *ppi[2][NFLD]; /* pointers to fields in lines */
-char *s1,*s2;
-int fj1 = 1;    /* join of this field of file 1 */
-int fj2 = 1;    /* join of this field of file 2 */
-int olist[2*NFLD];  /* output these fields */
-int olistf[2*NFLD]; /* from these files */
-int no; /* number of entries in olist */
-int sep1    = ' ';  /* default field separator */
-int sep2    = '\t';
-char*   null    = "";
+char buf[2][BUFSIZ]; /*input lines */
+char *ppi[2][NFLD];  /* pointers to fields in lines */
+char *s1, *s2;
+int fj1 = 1;          /* join of this field of file 1 */
+int fj2 = 1;          /* join of this field of file 2 */
+int olist[2 * NFLD];  /* output these fields */
+int olistf[2 * NFLD]; /* from these files */
+int no;               /* number of entries in olist */
+int sep1 = ' ';       /* default field separator */
+int sep2 = '\t';
+char *null = "";
 int unpub1;
 int unpub2;
 int aflg;
 
-main(argc, argv)
-char *argv[];
+static void error(char *fmt, ...);
+static int input(int n);
+static int cmp(char *s1, char *s2);
+static void output(int on1, int on2);
+
+int main(int argc, char *argv[])
 {
     int i;
     int n1, n2;
@@ -38,7 +44,7 @@ char *argv[];
             break;
         switch (argv[1][1]) {
         case 'a':
-            switch(argv[1][2]) {
+            switch (argv[1][2]) {
             case '1':
                 aflg |= 1;
                 break;
@@ -58,7 +64,7 @@ char *argv[];
             sep1 = sep2 = argv[1][2];
             break;
         case 'o':
-            for (no = 0; no < 2*NFLD; no++) {
+            for (no = 0; no < 2 * NFLD; no++) {
                 if (argv[2][0] == '1' && argv[2][1] == '.') {
                     olistf[no] = F1;
                     olist[no] = atoi(&argv[2][2]);
@@ -90,7 +96,7 @@ char *argv[];
     if (argc != 3)
         error("usage: join [-an] [-estring] [-j1 x -j2 y] [-o list] [-tc] file1 file2");
     fj1--;
-    fj2--;  /* everyone else believes in 0 origin */
+    fj2--; /* everyone else believes in 0 origin */
     s1 = ppi[F1][fj1];
     s2 = ppi[F2][fj2];
     if (argv[1][0] == '-')
@@ -100,21 +106,23 @@ char *argv[];
     if ((f[F2] = fopen(argv[2], "r")) == NULL)
         error("can't open %s", argv[2]);
 
-#define get1() n1=input(F1)
-#define get2() n2=input(F2)
+#define get1() n1 = input(F1)
+#define get2() n2 = input(F2)
     get1();
     bot2 = ftell(f[F2]);
     get2();
-    while(n1>0 && n2>0 || aflg!=0 && n1+n2>0) {
-        if(n1>0 && n2>0 && comp()>0 || n1==0) {
-            if(aflg&2) output(0, n2);
+    while (n1 > 0 && n2 > 0 || aflg != 0 && n1 + n2 > 0) {
+        if (n1 > 0 && n2 > 0 && comp() > 0 || n1 == 0) {
+            if (aflg & 2)
+                output(0, n2);
             bot2 = ftell(f[F2]);
             get2();
-        } else if(n1>0 && n2>0 && comp()<0 || n2==0) {
-            if(aflg&1) output(n1, 0);
+        } else if (n1 > 0 && n2 > 0 && comp() < 0 || n2 == 0) {
+            if (aflg & 1)
+                output(n1, 0);
             get1();
         } else /*(n1>0 && n2>0 && comp()==0)*/ {
-            while(n2>0 && comp()==0) {
+            while (n2 > 0 && comp() == 0) {
                 output(n1, n2);
                 top2 = ftell(f[F2]);
                 get2();
@@ -122,15 +130,15 @@ char *argv[];
             fseek(f[F2], bot2, 0);
             get2();
             get1();
-            for(;;) {
-                if(n1>0 && n2>0 && comp()==0) {
+            for (;;) {
+                if (n1 > 0 && n2 > 0 && comp() == 0) {
                     output(n1, n2);
                     get2();
-                } else if(n1>0 && n2>0 && comp()<0 || n2==0) {
+                } else if (n1 > 0 && n2 > 0 && comp() < 0 || n2 == 0) {
                     fseek(f[F2], bot2, 0);
                     get2();
                     get1();
-                } else /*(n1>0 && n2>0 && comp()>0 || n1==0)*/{
+                } else /*(n1>0 && n2>0 && comp()>0 || n1==0)*/ {
                     fseek(f[F2], top2, 0);
                     bot2 = top2;
                     get2();
@@ -139,10 +147,11 @@ char *argv[];
             }
         }
     }
-    return(0);
+    return (0);
 }
 
-input(n)        /* get input line and split into fields */
+/* get input line and split into fields */
+int input(int n)
 {
     register int i, c;
     char *bp;
@@ -151,11 +160,11 @@ input(n)        /* get input line and split into fields */
     bp = buf[n];
     pp = ppi[n];
     if (fgets(bp, BUFSIZ, f[n]) == NULL)
-        return(0);
-    for (i = 0; ; i++) {
-        if (sep1 == ' ')    /* strip multiples */
+        return (0);
+    for (i = 0;; i++) {
+        if (sep1 == ' ') /* strip multiples */
             while ((c = *bp) == sep1 || c == sep2)
-                bp++;   /* skip blanks */
+                bp++; /* skip blanks */
         else
             c = *bp;
         if (c == '\n' || c == '\0')
@@ -163,21 +172,21 @@ input(n)        /* get input line and split into fields */
         *pp++ = bp; /* record beginning */
         while ((c = *bp) != sep1 && c != '\n' && c != sep2 && c != '\0')
             bp++;
-        *bp++ = '\0';   /* mark end by overwriting blank */
-            /* fails badly if string doesn't have \n at end */
+        *bp++ = '\0'; /* mark end by overwriting blank */
+                      /* fails badly if string doesn't have \n at end */
     }
     *pp = 0;
-    return(i);
+    return (i);
 }
 
-output(on1, on2)    /* print items from olist */
-int on1, on2;
+/* print items from olist */
+void output(int on1, int on2)
 {
     int i;
     char *temp;
 
-    if (no <= 0) {  /* default case */
-        printf("%s", on1? ppi[F1][fj1]: ppi[F2][fj2]);
+    if (no <= 0) { /* default case */
+        printf("%s", on1 ? ppi[F1][fj1] : ppi[F2][fj2]);
         for (i = 0; i < on1; i++)
             if (i != fj1)
                 printf("%c%s", sep1, ppi[F1][i]);
@@ -188,9 +197,8 @@ int on1, on2;
     } else {
         for (i = 0; i < no; i++) {
             temp = ppi[olistf[i]][olist[i]];
-            if(olistf[i]==F1 && on1<=olist[i] ||
-               olistf[i]==F2 && on2<=olist[i] ||
-               *temp==0)
+            if (olistf[i] == F1 && on1 <= olist[i] || olistf[i] == F2 && on2 <= olist[i] ||
+                *temp == 0)
                 temp = null;
             printf("%s", temp);
             if (i == no - 1)
@@ -201,17 +209,18 @@ int on1, on2;
     }
 }
 
-error(s1, s2, s3, s4, s5)
-char *s1;
+void error(char *fmt, ...)
 {
+    va_list args;
+    va_start(args, fmt);
     fprintf(stderr, "join: ");
-    fprintf(stderr, s1, s2, s3, s4, s5);
+    vfprintf(stderr, fmt, args);
     fprintf(stderr, "\n");
+    va_end(args);
     exit(1);
 }
 
-cmp(s1, s2)
-char *s1, *s2;
+int cmp(char *s1, char *s2)
 {
-    return(strcmp(s1, s2));
+    return (strcmp(s1, s2));
 }