Feat: added buffered io from plan9

As we no longer have the FILE type, we need to buffer our reading and
writing so that we don't have to make so many syscalls. The API is nice
so that we can buffer other readers. We will update it so that it eats
io·Readers/io·Writers.

17 files changed, 600 insertions, 5 deletions

diff --git a/src/base/bufio/flush.c b/src/base/bufio/flush.c
new file mode 100644
index 0000000..0974766
--- /dev/null
+++ b/src/base/bufio/flush.c
@@ -0,0 +1,36 @@
+#include "internal.h"
+
+int
+bio·flush(io·Header *io)
+{
+    intptr ni, no;
+
+    switch(io->state){
+    case io·BufWtr:
+        if((ni = io->cap + io->olen))
+            return 0;
+
+        sys·write(io->fd, ni, io->b, &no);
+
+        if(no!=ni){
+            io->pos += ni;
+            io->olen = -io->cap;
+            return 0;
+        }
+
+        io->state = io·BufNil;
+        io->olen  = 0;
+        break;
+
+    case io·BufEof:
+        io->state = io·BufRdr;
+        /* fallthrough */
+    case io·BufRdr:
+        io->ilen = 0;
+        io->g = io->e;
+        return 0;
+    default:
+        ;
+    }
+    return io·BufEof;
+}
diff --git a/src/base/bufio/getc.c b/src/base/bufio/getc.c
new file mode 100644
index 0000000..264e01d
--- /dev/null
+++ b/src/base/bufio/getc.c
@@ -0,0 +1,45 @@
+#include "internal.h"
+
+int
+bio·getc(io·Header *io)
+{
+    int i;
+    intptr nr;
+
+loop:
+    i = io->ilen;
+    if(i != 0){
+        io->ilen = i+1;
+        return io->e[i];
+    }
+
+    if(io->state != io·BufRdr){
+        if(io->state == io·BufEnd)
+            io->state = io·BufRdr;
+        return io·BufEof;
+    }
+
+    /*
+     * get next buffer, try to keep io·BufUngets bytes
+     * pre-catenated from the previous read to allow for ungets 
+     */
+    mem·move(io->b-io·BufUngets, io->e-io·BufUngets, io·BufUngets);
+    if(sys·read(io->fd, io->cap, io->b, &nr)){
+        io->state = io·BufNil;
+        return io·BufEof;
+    }
+    if(nr == 0){
+        io->state = io·BufEnd;
+        return io·BufEof;
+    }
+
+    if(nr < io->cap){
+        mem·move(io->e-i-io·BufUngets, io->b-io·BufUngets, i+io·BufUngets);
+        io->g = io->e-i;
+    }
+
+    io->ilen = -i;
+    io->pos += +i;
+
+    goto loop;
+}
diff --git a/src/base/bufio/getr.c b/src/base/bufio/getr.c
new file mode 100644
index 0000000..579a387
--- /dev/null
+++ b/src/base/bufio/getr.c
@@ -0,0 +1,29 @@
+#include "internal.h"
+
+rune
+bio·getr(io·Header *io)
+{
+    int c, i;
+    rune r;
+    char buf[UTFmax];
+
+    c = bio·getc(io);
+    if(utf8·onebyte(c)){
+        io->runesz = 1;
+        return c;
+    }
+    buf[0] = c;
+
+    for(i=1;;){
+        if((c = bio·getc(io))<0)
+            return c;
+
+        buf[i++] = c;
+        if(utf8·fullrune(buf, i)){
+            io->runesz = utf8·decode(buf, &r);
+            while(i-- > io->runesz)
+                bio·ungetc(io);
+            return r;
+        }
+    }
+}
diff --git a/src/base/bufio/init.c b/src/base/bufio/init.c
new file mode 100644
index 0000000..7e6dcee
--- /dev/null
+++ b/src/base/bufio/init.c
@@ -0,0 +1,102 @@
+#include "internal.h"
+
+#define MAXHEADERS 20
+static io·Header *tracked[MAXHEADERS];
+static int doexit;
+
+static void
+untrackall(void *arg)
+{
+    int i;
+    io·Header *it;
+
+    for(i=0; i < MAXHEADERS; i++){
+        it = tracked[i];
+        if(it){
+            tracked[i] = nil;
+            bio·flush(it);
+        }
+    }
+}
+
+static void
+untrack(io·Header *io)
+{
+    int i;
+
+    for(i=0; i<arrlen(tracked); i++){
+        if(tracked[i] == io)
+            tracked[i] = nil;
+    }
+}
+
+static void
+track(io·Header *io)
+{
+    int i;
+
+    untrack(io);
+    for(i=0; i<arrlen(tracked); i++){
+        if(!tracked[i]){
+            tracked[i] = io;
+            break;
+        }
+    }
+
+    if(!doexit){
+        doexit = 1;
+        rt·atexit(untrackall, nil);
+    }
+}
+
+int
+bio·initcap(io·Header *io, int fd, int mode, int cap, uchar *buf)
+{
+    buf += io·BufUngets;
+    cap += io·BufUngets;
+
+    switch(mode & ~(sys·OCloseExec|sys·OTrunc)){
+    default:
+        fmt·fprint(2, "initcap: unknown mode %d\n" , mode);
+        return io·BufErr;
+    case sys·ORead:
+        io->state = io·BufRdr;
+        io->olen  = 0;
+        break;
+    case sys·OWrite:
+        track(io);
+        io->state = io·BufWtr;
+        io->olen  = -cap;
+        break;
+    }
+
+    io->b   = buf;
+    io->e   = buf+cap;
+    io->g   = io->e;
+    io->fd  = fd;
+    io->cap = cap;
+    io->pos = io->runesz = io->flag = io->ilen = io->line = 0;
+    return 0;
+}
+
+int
+bio·init(io·Buffer *io, int fd, int mode)
+{
+    return bio·initcap(header(io), fd, mode, io·BufLen + io·BufUngets, io->b);
+}
+
+int
+bio·close(io·Header *io)
+{
+    int err;
+
+    untrack(io);
+
+    err = bio·flush(io);
+    if(io->flag == io·BufMagic){
+        io->flag = 0;
+        if((err=sys·close(io->fd)))
+            return err;
+    }
+    return 0;
+}
diff --git a/src/base/bufio/offset.c b/src/base/bufio/offset.c
new file mode 100644
index 0000000..15579c4
--- /dev/null
+++ b/src/base/bufio/offset.c
@@ -0,0 +1,24 @@
+#include "internal.h"
+
+intptr
+bio·offset(io·Header *io)
+{
+    intptr n;
+    switch(io->state){
+    default:
+        fmt·fprint(2, "offset: unknown state %d\n", io->state);
+        n = io·BufEof;
+        break;
+
+    case io·BufEnd:
+    case io·BufRdr:
+        n = io->pos + io->ilen;
+        break;
+
+    case io·BufWtr:
+        n = io->pos + (io->cap + io->olen);
+        break;
+    }
+
+    return n;
+}
diff --git a/src/base/bufio/open.c b/src/base/bufio/open.c
new file mode 100644
index 0000000..29ccae1
--- /dev/null
+++ b/src/base/bufio/open.c
@@ -0,0 +1,27 @@
+#include "internal.h"
+
+int
+bio·open(char *path, int flag, io·Buffer *io)
+{
+    int fd;
+    switch(flag & ~(sys·OCloseExec|sys·OTrunc)){
+    default:
+        fmt·fprint(2, "open: unknown flag %d\n", flag);
+        return 1;
+
+    case sys·ORead:
+        if(sys·open(path, flag, 0, &fd))
+            return 1;
+        break;
+
+    case sys·OWrite:
+        if(sys·open(path, flag, 0666, &fd))
+            return 1;
+        break;
+    }
+    if(bio·openfd(fd, flag, io)){
+        sys·close(fd);
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/base/bufio/openfd.c b/src/base/bufio/openfd.c
new file mode 100644
index 0000000..66ca967
--- /dev/null
+++ b/src/base/bufio/openfd.c
@@ -0,0 +1,12 @@
+#include "internal.h"
+
+int
+bio·openfd(int fd, int flag, io·Buffer *io)
+{
+    int err;
+    if((err=bio·init(io, fd, flag)))
+        return err;
+
+    io->flag = io·BufMagic;
+    return 0;
+}
diff --git a/src/base/bufio/print.c b/src/base/bufio/print.c
new file mode 100644
index 0000000..04a85f9
--- /dev/null
+++ b/src/base/bufio/print.c
@@ -0,0 +1,14 @@
+#include "internal.h"
+
+int
+bio·print(io·Header *io, char *fmt, ...)
+{
+    int n;
+    va_list args;
+
+    va_start(args, fmt);
+    n = bio·vprint(io, fmt, args);
+    va_end(args);
+
+    return n;
+}
diff --git a/src/base/bufio/putc.c b/src/base/bufio/putc.c
new file mode 100644
index 0000000..e91a1f1
--- /dev/null
+++ b/src/base/bufio/putc.c
@@ -0,0 +1,19 @@
+#include "internal.h"
+
+int
+bio·putc(io·Header *io, int c)
+{
+    intptr i;
+
+    for(;;){
+        i = io->olen;
+        if(i){
+            io->e[i++] = c;
+            io->olen = i;
+            return 0;
+        }
+        if(bio·flush(io) == io·BufEof)
+            break;
+    }
+    return io·BufEof;
+}
diff --git a/src/base/bufio/read.c b/src/base/bufio/read.c
new file mode 100644
index 0000000..ad0275c
--- /dev/null
+++ b/src/base/bufio/read.c
@@ -0,0 +1,54 @@
+#include "internal.h"
+
+intptr
+bio·read(io·Header *io, intptr len, void *buf)
+{
+    uchar *b;
+    intptr c0, c, nr, n, ic;
+
+    b = buf;
+    c = len;
+    ic = io->ilen; // how many bytes we've read and not flushed
+
+    while(c > 0){
+        n = -ic;
+        if(n > c)
+            n = c;
+        if(n == 0){
+            /* only continue if we are a file reader */
+            if(io->state != io·BufRdr)
+                break;
+
+            /* get more bytes */
+            if(sys·read(io->fd, io->cap, io->b, &nr)){
+                io->state = io·BufNil;
+                break;
+            }
+
+            if(nr == 0){
+                io->state = io·BufEnd;
+                break;
+            }
+
+            /* shift bytes within buffer so they end at terminal */
+            io->g = io->b;
+            io->pos += nr;
+            if(nr < io->cap){
+                io->g = io->e-nr;
+                mem·move(io->g, io->b, nr);
+            }
+            ic -= nr;
+            continue;
+        }
+        /* move our read bytes into the caller's buffer */
+        mem·move(b, io->e+ic, n);
+        c  -= n;
+        ic += n;
+        b  += n;
+    }
+    io->ilen = ic;
+    if(c == len && io->state == io·BufNil)
+        return -1;
+
+    return len-c;
+}
diff --git a/src/base/bufio/readuntil.c b/src/base/bufio/readuntil.c
new file mode 100644
index 0000000..8084cca
--- /dev/null
+++ b/src/base/bufio/readuntil.c
@@ -0,0 +1,64 @@
+#include "internal.h"
+
+void *
+bio·readuntil(io·Header *io, int delim)
+{
+    char *b, *e;
+    intptr i, j;
+
+    i = -io->ilen;
+    if(i==0){
+        if(io->state != io·BufRdr){
+            if(io->state == io·BufEnd)
+                io->state = io·BufRdr;
+            io->line = 0;
+            io->g = io->e;
+            return nil;
+        }
+    }
+
+    /* best case, we find it in the remaining bytes */
+    b = (char*)io->e - i;
+    if((e = mem·findc(b, i, delim)) != nil){
+        j = (e - b)+1;
+        io->line  = j;
+        io->ilen += j;
+        return b;
+    }
+    /* ok no luck, shift over the data and get more */
+    if(i < io->cap)
+        mem·move(io->b, b, i);
+    io->g = io->b;
+    /* write to the buffer while we search for delim */
+    b = (char *)io->b + i;
+    while(i < io->cap){
+        if(sys·read(io->fd, io->cap-i, b, &j)){
+            mem·move(io->e-i, io->b, i);
+            io->line = +i;
+            io->ilen = -i;
+            io->g = io->e - i;
+            return 0;
+        }
+        io->pos += j;
+        i += j;
+        e = mem·findc(b, j, delim);
+        if(e!=nil){
+            /* finally have a hit. reset the world */
+            b = (char*)io->e - i;
+            if(i < io->cap){
+                mem·move(b, io->b, i);
+                io->g = (uchar *)b;
+            }
+            j = (e - (char*)io->b) + 1;
+            io->line = j;
+            io->ilen = j - i;
+            return b;
+        }
+        b += j;
+    }
+
+    io->line = +io->cap;
+    io->ilen = -io->cap;
+    io->g = io->b;
+    return 0;
+}
diff --git a/src/base/bufio/rules.mk b/src/base/bufio/rules.mk
index 8089e77..4546aeb 100644
--- a/src/base/bufio/rules.mk
+++ b/src/base/bufio/rules.mk
@@ -1,5 +1,17 @@
-# SRCS_$(d)+=\
-# 	$(d)/bufio/get.c\
-# 	$(d)/bufio/read.c\
-# 	$(d)/bufio/reader.c\
-# 	$(d)/bufio/unget.c\
+SRCS_$(d)+=\
+	$(d)/bufio/flush.c\
+	$(d)/bufio/getc.c\
+	$(d)/bufio/getr.c\
+	$(d)/bufio/init.c\
+	$(d)/bufio/offset.c\
+	$(d)/bufio/open.c\
+	$(d)/bufio/openfd.c\
+	$(d)/bufio/print.c\
+	$(d)/bufio/putc.c\
+	$(d)/bufio/read.c\
+	$(d)/bufio/readuntil.c\
+	$(d)/bufio/seek.c\
+	$(d)/bufio/ungetc.c\
+	$(d)/bufio/ungetr.c\
+	$(d)/bufio/vprint.c\
+	$(d)/bufio/write.c
diff --git a/src/base/bufio/seek.c b/src/base/bufio/seek.c
new file mode 100644
index 0000000..5d25173
--- /dev/null
+++ b/src/base/bufio/seek.c
@@ -0,0 +1,57 @@
+#include "internal.h"
+
+int
+bio·seek(io·Header *io, intptr offset, int whence, intptr *pos)
+{
+    intptr n,d,cap;
+
+    switch(io->state){
+    default:
+        fmt·fprint(2, "seek: unknown state %d\n", io->state);
+        return io·BufEof;
+    case io·BufEnd:
+        io->state = io·BufRdr;
+        io->ilen = 0;
+        io->g = io->e;
+        /* fallthrough */
+    case io·BufRdr:
+        n = offset;
+        if(whence == sys·SeekCur){
+            n += bio·offset(io);
+            whence = sys·SeekSet;
+        }
+
+        /* can we seek inside our buffer */
+        if(whence == sys·SeekSet){
+            d = n - bio·offset(io);
+            cap = io->e - io->g;
+            if(-cap <= d && d <= cap){
+                io->ilen += d;
+                if(d >= 0){
+                    if(io->ilen <= 0){
+                        *pos = n;
+                        return 0;
+                    }
+                }else{
+                    if(io->e - io->g >= -io->ilen){
+                        *pos = n;
+                        return 0;
+                    }
+                }
+            }
+        }
+
+        /* nope, call the kernel to do it for us */
+        sys·seek(io->fd, offset, whence, &n);
+        io->ilen = 0;
+        io->g = io->e;
+        break;
+
+    case io·BufWtr:
+        bio·flush(io);
+        sys·seek(io->fd, offset, whence, &n);
+        break;
+    }
+    io->pos = *pos = n;
+    return 0;
+}
diff --git a/src/base/bufio/ungetc.c b/src/base/bufio/ungetc.c
new file mode 100644
index 0000000..70abbab
--- /dev/null
+++ b/src/base/bufio/ungetc.c
@@ -0,0 +1,13 @@
+#include "internal.h"
+
+int
+bio·ungetc(io·Header *io)
+{
+    if(io->state == io·BufEnd)
+        io->state = io·BufRdr;
+    if(io->state != io·BufRdr)
+        return io·BufEof;
+
+    io->ilen--;
+    return 0;
+}
diff --git a/src/base/bufio/ungetr.c b/src/base/bufio/ungetr.c
new file mode 100644
index 0000000..8abdc39
--- /dev/null
+++ b/src/base/bufio/ungetr.c
@@ -0,0 +1,13 @@
+#include "internal.h"
+
+rune
+bio·ungetr(io·Header *io)
+{
+    if(io->state == io·BufEnd)
+        io->state = io·BufRdr;
+    if(io->state != io·BufRdr)
+        return io·BufEof;
+    io->ilen  -= io->runesz;
+    io->runesz = 0;
+    return 0;
+}
diff --git a/src/base/bufio/vprint.c b/src/base/bufio/vprint.c
new file mode 100644
index 0000000..70be6bf
--- /dev/null
+++ b/src/base/bufio/vprint.c
@@ -0,0 +1,34 @@
+#include "internal.h"
+
+static int
+flush(fmt·State *fmt)
+{
+    io·Header *io = fmt->file;
+    io->olen = fmt->buffer.cur - fmt->buffer.end;
+    if(bio·flush(io))
+        return 0;
+
+    fmt->buffer.end = (char*)io->e;
+    fmt->buffer.cur = fmt->buffer.beg = fmt->buffer.end + io->olen;
+    return 1;
+}
+
+int
+bio·vprint(io·Header *io, char *fmt, va_list args)
+{
+    int n;
+    fmt·State f;
+
+    f.buffer.end = (char*)io->e;
+    f.buffer.beg = f.buffer.cur = (char*)(io->e + io->olen);
+    f.n     = 0;
+    f.file  = io;
+    f.flush = flush;
+
+    va_copy(f.args,args);
+    n = fmt·do(&f, fmt);
+    va_end(f.args);
+
+    io->olen = f.buffer.cur - f.buffer.beg;
+    return n;
+}
diff --git a/src/base/bufio/write.c b/src/base/bufio/write.c
new file mode 100644
index 0000000..8b64055
--- /dev/null
+++ b/src/base/bufio/write.c
@@ -0,0 +1,40 @@
+#include "internal.h"
+
+intptr
+bio·write(io·Header *io, intptr len, void *buf)
+{
+    char *b;
+    intptr c, o, nw, n;
+
+    b = buf;
+    c = len;
+    o = io->olen;
+
+    while(c > 0){
+        n = -o;
+        if(n > c)
+            n = c;
+        if(n == 0){
+            if(io->state != io·BufWtr)
+                return io·BufEof;
+            switch(sys·write(io->fd, io->cap, io->b, &nw)){
+            case 0:
+                if(nw != io->cap) goto error;
+                io->pos += nw;
+                o = -io->cap;
+                continue;
+            case sys·ErrorInterrupt:
+                io->state = io·BufNil;
+                /* fallthrough */
+            default: error:
+                return io·BufEof;
+            }
+        }
+        mem·move(io->e+o, b, n);
+        o += n;
+        c -= n;
+        b += n;
+    }
+    io->olen = o;
+    return len-c;
+}