Checkin: small sprawling updates

Small touches to multiple locations in base.
Nothing major

40 files changed, 215 insertions, 97 deletions

diff --git a/bin/status b/bin/status
index 77937a5..451a428 100755
--- a/bin/status
+++ b/bin/status
@@ -71,7 +71,7 @@ ipaddr() {
 }
 
 dostatus() {
-    exec xsetroot -name "$VOL│$MEM│$BAT|$IP│$CPU│$NML│$WTR│$TIM" &
+    exec xsetroot -name "$VOL│$MEM│$IP│$CPU│$NML│$WTR│$TIM" &
 }
 
 # signal handlers
diff --git a/include/base/macro/map.h b/include/base/macro/map.h
index 1f07eab..cbcb47d 100644
--- a/include/base/macro/map.h
+++ b/include/base/macro/map.h
@@ -22,8 +22,8 @@ static const double HASHFILL = 0.77;
   (flag[i >> 4] &= ~(3ul << ((i & 0xfU) << 1)))
 #define map·setdelete(flag, i) (flag[i >> 4] |= 1ul << ((i & 0xfU) << 1))
 
-#define map·flagsize(m) ((m) < 16 ? 1 : (m) >> 4)
-#define map·fill(m, x) (!map·iseither((m)->flag, (x)))
+#define map·flagsize(m)  ((m) < 16 ? 1 : (m) >> 4)
+#define map·filled(m, x) (!map·iseither((m)->flag, (x)))
 
 /* map types */
 #define MAP_STRUCT_BODY(key_t, val_t)                                          \
@@ -48,7 +48,7 @@ static const double HASHFILL = 0.77;
     (map)->len = (map)->occ = 0;                                               \
   }
 
-#define MAP_GET(i, map, key, hashfunc, equalfunc)                              \
+#define MAP_GET(map, i, keyv, hashfunc, equalfunc)                             \
   int32 k, last, mask, step;                                                   \
   if((map)->cap){                                                              \
     k    = 0;                                                                  \
@@ -57,11 +57,11 @@ static const double HASHFILL = 0.77;
     mask = 0;                                                                  \
     step = 0;                                                                  \
     mask = (map)->cap - 1;                                                     \
-    k    = hashfunc((key));                                                    \
+    k    = hashfunc((keyv));                                                   \
     i    = k & mask;                                                           \
     last = i;                                                                  \
     while(!map·isempty((map)->flag, i) &&                                      \
-          (map·isdelete((map)->flag, i) || !equalfunc((map)->key[i], (key)))){ \
+          (map·isdelete((map)->flag, i) || !equalfunc((map)->key[i], (keyv)))){\
       i = (i + (++step)) & mask;                                               \
       if(i == last){                                                           \
         i = (map)->cap;                                                        \
@@ -85,7 +85,7 @@ static const double HASHFILL = 0.77;
     else{                                                                      \
       new_flags = (mem).alloc((heap), map·flagsize(newcap), sizeof(int32));    \
       if(!new_flags) return -1;                                                \
-      mem·set(new_flags, map·flagsize(newcap) * sizeof(int32), 0xAA);          \
+      mem·set(new_flags, map·flagsize(newcap)*sizeof(int32), 0xAA);            \
       if((map)->cap < newcap){ /* expand */                                    \
         key_t *new_keys = (mem).alloc((heap), newcap, sizeof(key_t));          \
         if(!new_keys){                                                         \
@@ -154,39 +154,39 @@ static const double HASHFILL = 0.77;
       (map)->val = new_vals;                                                   \
     }                                                                          \
     (mem).free((heap), (map)->flag); /* free the working space */              \
-    (map)->flag      = new_flags;                                              \
+    (map)->flag = new_flags;                                                   \
     (map)->cap  = newcap;                                                      \
-    (map)->occ = (map)->len;                                                   \
+    (map)->occ  = (map)->len;                                                  \
     (map)->fill = (int32)((map)->cap * HASHFILL + 0.5);                        \
   }                                                                            \
   return 0;
 
-#define MAP_PUT(map, key, hashfunc, equalfunc, resizefunc, err)                \
+#define MAP_PUT(map, newkey, hashfunc, equalfunc, resizefunc, err)             \
     int32 x = 0;                                                               \
-    if(map->occ >= map->fill){                                                 \
-      if(map->cap > (map->len << 1)){                                          \
-        if(resizefunc(map, map->cap - 1) < 0){                                 \
+    if((map)->occ >= (map)->fill){                                             \
+      if((map)->cap > (map)->len << 1){                                        \
+        if(resizefunc((map), (map)->cap - 1) < 0){                             \
           *err = -1;                                                           \
-          return map->cap;                                                     \
+          return (map)->cap;                                                   \
         }                                                                      \
-      }else if(resizefunc(map, map->cap + 1) < 0){                             \
+      }else if(resizefunc((map), (map)->cap + 1) < 0){                         \
         *err = -1;                                                             \
-        return map->cap;                                                       \
+        return (map)->cap;                                                     \
       }                                                                        \
     }                                                                          \
                                                                                \
     {                                                                          \
-      int32 k, i, site, last, mask = map->cap - 1, step = 0;                   \
-      x = site = map->cap;                                                     \
-      k = hashfunc((key));                                                     \
+      int32 k, i, site, last, mask = (map)->cap - 1, step = 0;                 \
+      x = site = (map)->cap;                                                   \
+      k = hashfunc((newkey));                                                  \
       i = k & mask;                                                            \
-      if(map·isempty(map->flag, i))                                            \
+      if(map·isempty((map)->flag, i))                                          \
         x = i; /* for speed up */                                              \
       else{                                                                    \
         last = i;                                                              \
-        while(!map·isempty(map->flag, i) &&                                    \
-              (map·isdelete(map->flag, i) || !equalfunc(map->key[i], (key)))){ \
-          if(map·isdelete(map->flag, i))                                       \
+        while(!map·isempty((map)->flag, i) &&                                  \
+              (map·isdelete((map)->flag, i) || !equalfunc((map)->key[i], (newkey)))){ \
+          if(map·isdelete((map)->flag, i))                                     \
             site = i;                                                          \
           i = (i + (++step)) & mask;                                           \
           if(i == last){                                                       \
@@ -194,32 +194,32 @@ static const double HASHFILL = 0.77;
             break;                                                             \
           }                                                                    \
         }                                                                      \
-        if(x == map->cap){                                                     \
-          if(map·isempty(map->flag, i) && site != map->cap)                    \
+        if(x == (map)->cap){                                                   \
+          if(map·isempty((map)->flag, i) && site != (map)->cap)                \
             x = site;                                                          \
           else                                                                 \
             x = i;                                                             \
         }                                                                      \
       }                                                                        \
     }                                                                          \
-    if(map·isempty(map->flag, x)){ /* not present at all */                    \
-      map->key[x] = (key);                                                     \
-      map·setnotboth(map->flag, x);                                            \
-      ++map->len;                                                              \
-      ++map->occ;                                                              \
+    if(map·isempty((map)->flag, x)){ /* not present at all */                  \
+      (map)->key[x] = (newkey);                                                \
+      map·setnotboth((map)->flag, x);                                          \
+      ++(map)->len;                                                            \
+      ++(map)->occ;                                                            \
       *err = 1;                                                                \
-    }else if(map·isdelete(map->flag, x)){ /* deleted */                        \
-      map->key[x] = (key);                                                     \
-      map·setnotboth(map->flag, x);                                            \
-      ++map->len;                                                              \
+    }else if(map·isdelete((map)->flag, x)){ /* deleted */                      \
+      (map)->key[x] = (newkey);                                                \
+      map·setnotboth((map)->flag, x);                                          \
+      ++(map)->len;                                                            \
     }else                                                                      \
       *err = 0;                                                                \
     return x;
 
 #define MAP_DEL(map, x)                                                        \
-    if(x != map->cap && !map·iseither(map->flag, x)){                          \
-      map·setdelete(map->flag, x);                                             \
-      --map->len;                                                              \
+    if(x != (map)->cap && !map·iseither((map)->flag, x)){                      \
+      map·setdelete((map)->flag, x);                                           \
+      --(map)->len;                                                            \
     }
 
 /* set macro */
@@ -244,7 +244,7 @@ static const double HASHFILL = 0.77;
     (set)->len = (set)->occ = 0;                                               \
   }
 
-#define SET_GET(i, set, key, hashfunc, equalfunc )                             \
+#define SET_GET(set, i, keyv, hashfunc, equalfunc )                            \
   int32 k, last, mask, step;                                                   \
   if((set)->cap){                                                              \
     k    = 0;                                                                  \
@@ -253,11 +253,11 @@ static const double HASHFILL = 0.77;
     mask = 0;                                                                  \
     step = 0;                                                                  \
     mask = (set)->cap - 1;                                                     \
-    k    = hashfunc((key));                                                    \
+    k    = hashfunc((keyv));                                                   \
     i    = k & mask;                                                           \
     last = i;                                                                  \
     while(!map·isempty((set)->flag, i) &&                                      \
-          (map·isdelete((set)->flag, i) || !equalfunc((set)->key[i], (key)))){ \
+          (map·isdelete((set)->flag, i) || !equalfunc((set)->key[i], (keyv)))){\
       i = (i + (++step)) & mask;                                               \
       if(i == last){                                                           \
         i = (set)->cap;                                                        \
diff --git a/include/base/math.h b/include/base/math.h
index 69d344e..65d3058 100644
--- a/include/base/math.h
+++ b/include/base/math.h
@@ -19,6 +19,7 @@ double	math·log10(double);
 double	math·exp(double);
 double	math·floor(double);
 double	math·ceil(double);
+double	math·round(double);
 double	math·sin(double);
 double	math·cos(double);
 double	math·tan(double);
diff --git a/include/base/memory.h b/include/base/memory.h
index 6bf3cbc..a97615e 100644
--- a/include/base/memory.h
+++ b/include/base/memory.h
@@ -31,6 +31,7 @@ typedef struct mem·BufHead
 
 #define mem·buffree(b)       ((b) ? (free(mem·bufhdr(b)), (b) = nil) : 0)
 #define mem·buffit(b, n)     ((n) <= mem·bufcap(b) ? 0 : ((b) = mem·bufgrow((b), (n), sizeof(*(b)))))
+#define mem·bufreset(b)      ((b) ? (mem·bufhdr(b)->len=0) : 0)
 
 #define mem·bufpush(b, ...)  (mem·buffit((b), 1 + mem·buflen(b)), (b)[mem·bufhdr(b)->len++] = (__VA_ARGS__))
 #define mem·bufaddn(b, n)    (mem·buffit(b, mem·buflen(b)+n), mem·bufhdr(b)->len += n, b+mem·bufhdr(b)->len-n)
@@ -50,8 +51,8 @@ typedef struct mem·Pool  mem·Pool;
 typedef struct mem·Arena mem·Arena;
 
 typedef struct mem·Allocator {
-    void *(*alloc)(void *heap, long n, uintptr size);
-    void *(*realloc)(void *heap, void *ptr, long n, uintptr size);
+    void *(*alloc)(void *heap, uintptr n, uintptr size);
+    void *(*realloc)(void *heap, void *ptr, uintptr n, uintptr size);
     void  (*free)(void *heap, void *ptr);
 } mem·Allocator;
 
diff --git a/include/base/sort.h b/include/base/sort.h
index e9a0e87..703642e 100644
--- a/include/base/sort.h
+++ b/include/base/sort.h
@@ -1,18 +1,18 @@
 #pragma once
 
-void sort·int(uintptr n, int arr[]);
-void sort·int8(uintptr n, int8 arr[]);
-void sort·int16(uintptr n, int16 arr[]);
-void sort·int32(uintptr n, int32 arr[]);
-void sort·int64(uintptr n, int64 arr[]);
+void sort·int(int arr[], uintptr n);
+void sort·int8(int8 arr[], uintptr n);
+void sort·int16(int16 arr[], uintptr n);
+void sort·int32(int32 arr[], uintptr n);
+void sort·int64(int64 arr[], uintptr n);
 
-void sort·uint(uintptr n, uint arr[]);
-void sort·uint8(uintptr n, uint8 arr[]);
-void sort·uint16(uintptr n, uint16 arr[]);
-void sort·uint32(uintptr n, uint32 arr[]);
-void sort·uint64(uintptr n, uint64 arr[]);
+void sort·uint(uint arr[], uintptr n);
+void sort·uint8(uint8 arr[], uintptr n);
+void sort·uint16(uint16 arr[], uintptr n);
+void sort·uint32(uint32 arr[], uintptr n);
+void sort·uint64(uint64 arr[], uintptr n);
 
-void sort·float(uintptr n, float arr[]);
-void sort·double(uintptr n, double arr[]);
+void sort·float(float arr[], uintptr n);
+void sort·double(double arr[], uintptr n);
 
-void sort·string(uintptr n, byte* arr[]);
+void sort·string(byte* arr[], uintptr n);
diff --git a/include/base/string.h b/include/base/string.h
index 20bf21b..2efbe0a 100644
--- a/include/base/string.h
+++ b/include/base/string.h
@@ -39,8 +39,8 @@ long     str·asint(char *s, char **end, int base);
 double   str·asfloat(char *s, char **end);
 
 /* augmented string functions */
-string  string·makecap(char *s, vlong len, vlong cap);
-string  string·makelen(char *s, vlong len);
+string  string·nnmake(char *s, vlong len, vlong cap);
+string  string·nmake(char *s, vlong len);
 string  string·make(char *s);
 string  string·makef(char *fmt, ...);
 void    string·free(string s);
diff --git a/include/base/utf.h b/include/base/utf.h
index 19f345f..b72168c 100644
--- a/include/base/utf.h
+++ b/include/base/utf.h
@@ -31,7 +31,8 @@ int     utf8·isspace(rune r);
 int     utf8·istitle(rune r);
 int     utf8·ispunct(rune r);
 int     utf8·isupper(rune r);
-int     utf8·islower(rune r);
+
+int     utf8·printable(rune r);
 
 rune    utf8·toupper(rune r);
 rune    utf8·tolower(rune r);
diff --git a/rules.mk b/rules.mk
index 85bee9b..a2e5bf5 100644
--- a/rules.mk
+++ b/rules.mk
@@ -13,7 +13,7 @@ debug: INIT   :=
 debug: FINI   :=
 debug: targets
 
-release: CFLAGS += -O2 -mtune=native -flto #-DNDEBUG
+release: CFLAGS += -O3 -mtune=native -flto #-DNDEBUG
 release: targets
 
 # Targets & array of sources & intermediates
diff --git a/src/base/math/round.c b/src/base/math/round.c
new file mode 100644
index 0000000..a815152
--- /dev/null
+++ b/src/base/math/round.c
@@ -0,0 +1,13 @@
+#include <u.h>
+#include <base.h>
+
+double
+math·round(double x)
+{
+    double f;
+
+    f = math·floor(x);
+    if((x-f) > 0.5)
+        return f+1;
+    return f;
+}
diff --git a/src/base/mem/arena.c b/src/base/mem/arena.c
index cb1af74..32c4ea8 100644
--- a/src/base/mem/arena.c
+++ b/src/base/mem/arena.c
@@ -26,13 +26,13 @@ struct mem·Arena
 };
 
 static void*
-·arenaalloc(void *heap, long n, uintptr size)
+·arenaalloc(void *heap, uintptr n, uintptr size)
 {
     return mem·arenaalloc(heap, n, size);
 }
 
 static void*
-·arenarealloc(void *heap, void *old, long n, uintptr size)
+·arenarealloc(void *heap, void *old, uintptr n, uintptr size)
 {
     /* does not free */
     return mem·arenaalloc(heap, n, size);
diff --git a/src/base/mem/compare.c b/src/base/mem/compare.c
index a2cdd1f..eadd1fa 100644
--- a/src/base/mem/compare.c
+++ b/src/base/mem/compare.c
@@ -1,7 +1,7 @@
 #include <u.h>
 
 int
-mem·compare(void *qry, void *ref, uintptr size)
+mem·compare(void *qry, uintptr size, void *ref)
 {
     intptr i;
     char *q=qry, *r=ref;
diff --git a/src/base/mem/interface.c b/src/base/mem/interface.c
index aa76c85..374fac0 100644
--- a/src/base/mem/interface.c
+++ b/src/base/mem/interface.c
@@ -6,17 +6,12 @@ static void
 }
 
 static void *
-·alloc(void *_, uint n, ulong size) {
-    return malloc(n*size);
-}
-
-static void *
-·calloc(void *_, long n, ulong size) {
+·calloc(void *_, uintptr n, uintptr size) {
     return calloc(n, size);
 }
 
 static void *
-·realloc(void *_, void *ptr, long n, ulong size) {
+·realloc(void *_, void *ptr, uintptr n, uintptr size) {
     return realloc(ptr, n*size);
 }
 
diff --git a/src/base/sort/double.c b/src/base/sort/double.c
index c3feac2..8dfc721 100644
--- a/src/base/sort/double.c
+++ b/src/base/sort/double.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·double(uintptr sz, double arr[])
+sort·double(double arr[],uintptr sz)
 {
     double tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/float.c b/src/base/sort/float.c
index 57bd482..a62af54 100644
--- a/src/base/sort/float.c
+++ b/src/base/sort/float.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·float(uintptr sz, float arr[])
+sort·float(float arr[], uintptr sz)
 {
     float tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/int.c b/src/base/sort/int.c
index 33e1def..8e7cae7 100644
--- a/src/base/sort/int.c
+++ b/src/base/sort/int.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·int(uintptr sz, int arr[])
+sort·int(int arr[], uintptr sz)
 {
     int tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/int16.c b/src/base/sort/int16.c
index 072a3eb..ab690fb 100644
--- a/src/base/sort/int16.c
+++ b/src/base/sort/int16.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·int16(uintptr sz, int16 arr[])
+sort·int16(int16 arr[], uintptr sz)
 {
     int16 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/int32.c b/src/base/sort/int32.c
index 27b3b7b..bf209f0 100644
--- a/src/base/sort/int32.c
+++ b/src/base/sort/int32.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·int32(uintptr sz, int32 arr[])
+sort·int32(int32 arr[], uintptr sz)
 {
     int32 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/int64.c b/src/base/sort/int64.c
index b3fa5d4..21387f6 100644
--- a/src/base/sort/int64.c
+++ b/src/base/sort/int64.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·int64(uintptr sz, int64 arr[])
+sort·int64(int64 arr[], uintptr sz)
 {
     int64 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/int8.c b/src/base/sort/int8.c
index 5848e6e..fab5dc3 100644
--- a/src/base/sort/int8.c
+++ b/src/base/sort/int8.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·int8(uintptr sz, int8 arr[])
+sort·int8(int8 arr[], uintptr sz)
 {
     int8 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/string.c b/src/base/sort/string.c
index e8fae66..8f9d05a 100644
--- a/src/base/sort/string.c
+++ b/src/base/sort/string.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·string(uintptr sz, byte* arr[])
+sort·string(byte* arr[], uintptr sz)
 {
     byte *tmp;
 #define LESS(i, j) (str·compare(arr[i], arr[j]) < 0)
diff --git a/src/base/sort/uint.c b/src/base/sort/uint.c
index 5b27330..68c9a70 100644
--- a/src/base/sort/uint.c
+++ b/src/base/sort/uint.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·uint(uintptr sz, uint arr[])
+sort·uint(uint arr[], uintptr sz)
 {
     uint tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/uint16.c b/src/base/sort/uint16.c
index 2b635b4..d0e4c05 100644
--- a/src/base/sort/uint16.c
+++ b/src/base/sort/uint16.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·uint16(uintptr sz, uint16 arr[])
+sort·uint16(uint16 arr[], uintptr sz)
 {
     uint16 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/uint32.c b/src/base/sort/uint32.c
index 99a58cf..ccc8499 100644
--- a/src/base/sort/uint32.c
+++ b/src/base/sort/uint32.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·uint32(uintptr sz, uint32 arr[])
+sort·uint32(uint32 arr[], uintptr sz)
 {
     uint32 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/uint64.c b/src/base/sort/uint64.c
index 2769825..4134f33 100644
--- a/src/base/sort/uint64.c
+++ b/src/base/sort/uint64.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·uint64(uintptr sz, uint64 arr[])
+sort·uint64(uint64 arr[], uintptr sz)
 {
     uint64 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/sort/uint8.c b/src/base/sort/uint8.c
index ff02b3c..ef3ab1c 100644
--- a/src/base/sort/uint8.c
+++ b/src/base/sort/uint8.c
@@ -1,7 +1,7 @@
 #include "internal.h"
 
 void
-sort·uint8(uintptr sz, uint8 arr[])
+sort·uint8(uint8 arr[], uintptr sz)
 {
     uint8 tmp;
 #define LESS(i, j) (arr[i] < arr[j])
diff --git a/src/base/string/join.c b/src/base/string/join.c
index 04d4739..9286720 100644
--- a/src/base/string/join.c
+++ b/src/base/string/join.c
@@ -3,7 +3,7 @@
 string
 string·join(vlong len, byte** fields, byte* sep)
 {
-    string s = string·makecap("", 0, 10);
+    string s = string·nnmake("", 0, 10);
     int    j = 0;
 
     for (j = 0; j < len; j++) {
diff --git a/src/base/string/make.c b/src/base/string/make.c
index 50b8b98..ca38984 100644
--- a/src/base/string/make.c
+++ b/src/base/string/make.c
@@ -4,7 +4,7 @@
 // len defines the length of the c substring that we will copy into our buffer.
 // the backing buffer will have capacity cap.
 string
-string·makecap(byte *s, vlong len, vlong cap)
+string·nnmake(byte *s, vlong len, vlong cap)
 {
     struct Hdr* h;
 
@@ -34,13 +34,13 @@ cleanup:
 // new returns a new dynamic string object, initialized from the given c string.
 // the backing buffer capacity is equivalent to the string length.
 string
-string·makelen(byte *s, vlong len)
+string·nmake(byte *s, vlong len)
 {
     vlong sl = (!s) ? 0 : str·len(s);
     if(sl < len) panicf("attempted to take a bigger substring than string length");
 
     vlong cap = (len == 0) ? 1 : len;
-    return string·makecap(s, len, cap);
+    return string·nnmake(s, len, cap);
 }
 
 // new returns a new dynamic string object, initialized from the given c string.
@@ -49,5 +49,5 @@ string
 string·make(byte *s)
 {
     vlong len = (!s) ? 0 : str·len(s);
-    return string·makelen(s, len);
+    return string·nmake(s, len);
 }
diff --git a/src/base/string/makef.c b/src/base/string/makef.c
index 1e0d917..fb076af 100644
--- a/src/base/string/makef.c
+++ b/src/base/string/makef.c
@@ -9,7 +9,7 @@ string·makef(byte *fmt, ...)
     va_list args;
     char bytes[256];
 
-    s = string·makecap(nil, 0, arrlen(bytes));
+    s = string·nnmake(nil, 0, arrlen(bytes));
 
     va_start(args, fmt);
     do{
diff --git a/src/base/string/raw/atoi.c b/src/base/string/raw/atoi.c
index e62ec62..d407411 100644
--- a/src/base/string/raw/atoi.c
+++ b/src/base/string/raw/atoi.c
@@ -1,9 +1,16 @@
 long
 str·atoi(char *s)
 {
-    long n = 0;
+    long neg=0, n = 0;
+
+    /* check for sign */
+    if(*s == '-')
+        neg=1,s++;
+    else if(*s == '+')
+        s++;
+
     while(*s)
         n = 10*n + (*s++ - '0');
 
-    return n;
+    return neg ? -n : +n;
 }
diff --git a/src/base/string/raw/ncopy.c b/src/base/string/raw/ncopy.c
index cf18a4b..df0e9da 100644
--- a/src/base/string/raw/ncopy.c
+++ b/src/base/string/raw/ncopy.c
@@ -1,5 +1,7 @@
+#include <u.h>
+
 char *
-str·ncopy(char *dst, int n, char *src)
+str·ncopy(char *dst, intptr n, char *src)
 {
     while(*src && n-- > 0)
         *dst++ = *src++;
diff --git a/src/base/string/split.c b/src/base/string/split.c
index 56029e1..ead4c5b 100644
--- a/src/base/string/split.c
+++ b/src/base/string/split.c
@@ -18,7 +18,7 @@ string·split(string s, byte* tok)
 
     for(vlong i = 0; i < sL - tokL; i++){
         if((tokL == 1 && s[i] == tokL) || !mem·compare(s + i, tokL, tok)){
-            mem·bufpush(fields, string·makelen(s + start, i - start));
+            mem·bufpush(fields, string·nmake(s + start, i - start));
             if(fields[mem·buflen(fields) - 1] == nil) goto cleanup;
 
             start = i + tokL;
@@ -26,7 +26,7 @@ string·split(string s, byte* tok)
         }
     }
 
-    mem·bufpush(fields, string·makelen(s + start, sL - start));
+    mem·bufpush(fields, string·nmake(s + start, sL - start));
 
     return fields;
 
diff --git a/src/base/test.c b/src/base/test.c
index 6baaf78..ceb9532 100644
--- a/src/base/test.c
+++ b/src/base/test.c
@@ -23,7 +23,7 @@ test·sort()
         test[i] = rng·randi(1000000);
 
     t = clock();
-    sort·int(arrlen(test), test);
+    sort·int(test, arrlen(test));
     t = clock() - t;
     fmt·print("inlined code took %f ms to execute\n", 1000.*t/CLOCKS_PER_SEC);
 
diff --git a/src/base/utf/printable.c b/src/base/utf/printable.c
new file mode 100644
index 0000000..6a8219b
--- /dev/null
+++ b/src/base/utf/printable.c
@@ -0,0 +1,8 @@
+#include "internal.h"
+
+/* TODO: this is just ascii... */
+int
+utf8·printable(rune r)
+{
+    return (unsigned)r-0x20 < 0x5f;
+}
diff --git a/src/base/utf/rules.mk b/src/base/utf/rules.mk
index 0ed2f8b..934e376 100644
--- a/src/base/utf/rules.mk
+++ b/src/base/utf/rules.mk
@@ -8,6 +8,7 @@ SRCS_$(d)+=\
 	$(d)/utf/findlast.c\
 	$(d)/utf/canfit.c\
 	$(d)/utf/runelen.c\
+	$(d)/utf/printable.c\
 	$(d)/utf/len.c\
 	$(d)/utf/runetype-$(UNICODE).c\
 	$(d)/utf/runewidth-$(UNICODE).c
diff --git a/src/cmd/core/basename.c b/src/cmd/core/basename.c
index 6b84812..0015f5c 100644
--- a/src/cmd/core/basename.c
+++ b/src/cmd/core/basename.c
@@ -32,5 +32,6 @@ main(int argc, char *argv[])
             p[n] = 0;
     }
     sys·write(1,p,str·len(p),&x);
+    sys·write(1,"\n",1, &x);
     return 0;
 }
diff --git a/src/cmd/core/cat.c b/src/cmd/core/cat.c
index aeed1be..92b082d 100644
--- a/src/cmd/core/cat.c
+++ b/src/cmd/core/cat.c
@@ -11,15 +11,16 @@ usage(void)
 static void
 cat(int fd, char *s)
 {
+    int err;
     intptr nr, nw;
     char buf[8192];
 
-    while(!(sys·read(fd, buf, sizeof(buf), &nr))){
+    while(!(err=sys·read(fd, buf, sizeof(buf), &nr)) && nr>0){
         if(sys·write(1, buf, nr, &nw) || nr != nw)
             fmt·panic("write error copying %s: %r", s);
     }
 
-    if(nr<0)
+    if(err)
         fmt·panic("error reading %s: %r", s);
 }
 
diff --git a/src/cmd/core/date.c b/src/cmd/core/date.c
index 225333f..09ec39a 100644
--- a/src/cmd/core/date.c
+++ b/src/cmd/core/date.c
@@ -1,6 +1,5 @@
 #include <u.h>
 #include <base.h>
-#include <libfmt.h>
 
 static void
 usage(void)
diff --git a/sys/linux/port/os/constants.h b/sys/linux/port/os/constants.h
index 03bab2a..458c2c2 100644
--- a/sys/linux/port/os/constants.h
+++ b/sys/linux/port/os/constants.h
@@ -18,6 +18,75 @@
 #define sys·ModeSocket 0140000
 
 /* ioctl values */
+#define sys·IoCtlTermGet        0x5401
+#define sys·IoCtlTermSet        0x5402
+#define sys·IoCtlTermGetWinSize 0x5413
+#define sys·IoCtlTermSetWinSize 0x5414
+
+#define sys·TermVInterupt 0
+#define sys·TermVQuit	  1
+#define sys·TermVErase	  2
+#define sys·TermVKill	  3
+#define sys·TermVEOF	  4
+#define sys·TermVTime	  5
+#define sys·TermVMin	  6
+#define sys·TermVSwitch	  7
+#define sys·TermVStart	  8
+#define sys·TermVStop	  9
+#define sys·TermVSuspend 10
+#define sys·TermVEol	 11
+#define sys·TermVReprint 12
+#define sys·TermVDiscard 13
+#define sys·TermVWerase	 14
+#define sys·TermVLnext	 15
+#define sys·TermVEol2	 16
+
+#define sys·TermIgnBrk	0000001
+#define sys·TermBrkInt	0000002
+#define sys·TermIgnPar	0000004
+#define sys·TermParmRk	0000010
+#define sys·TermInpck	0000020
+#define sys·TermIStrip	0000040
+#define sys·TermILlcr	0000100
+#define sys·TermIgnCr	0000200
+#define sys·TermIcrNl	0000400
+#define sys·TermIucLc	0001000
+#define sys·TermIxOn	0002000
+#define sys·TermIxAny	0004000
+#define sys·TermIxOff	0010000
+#define sys·TermIMaxBel 0020000
+#define sys·TermIUtf8	0040000
+
+#define sys·TermOPost   0000001
+#define sys·TermOLcuc   0000002
+#define sys·TermONlCr   0000004
+#define sys·TermOCrNl   0000010
+#define sys·TermONoCr   0000020
+#define sys·TermONlret  0000040
+#define sys·TermOFill   0000100
+#define sys·TermOFDel   0000200
+
+#define sys·TermCSize   0000060
+#define sys·TermCS5     0000000
+#define sys·TermCS6     0000020
+#define sys·TermCS7     0000040
+#define sys·TermCS8     0000060
+#define sys·TermCStopb  0000100
+#define sys·TermCSead   0000200
+#define sys·TermParenB  0000400
+#define sys·TermParodD  0001000
+#define sys·TermHupCl   0002000
+#define sys·TermCLocal  0004000
+
+#define sys·TermISignal 0000001
+#define sys·TermICanon  0000002
+#define sys·TermEcho    0000010
+#define sys·TermEchoE   0000020
+#define sys·TermEchoK   0000040
+#define sys·TermEchoNl  0000100
+#define sys·TermNoFlsh  0000200
+#define sys·TermToStop  0000400
+#define sys·TermIExtend 0100000
 
 /* mmap */
 #define sys·ProtNone      0
diff --git a/sys/linux/port/os/types.h b/sys/linux/port/os/types.h
index e772b35..9452e39 100644
--- a/sys/linux/port/os/types.h
+++ b/sys/linux/port/os/types.h
@@ -108,4 +108,22 @@ struct sys·DirEntry
     char   name[]; /* filename */
 };
 
+/*
+ * terminal
+ */
+
+/* termios
+ * NOTE: this is incorrect for Mips and PowerPC...
+ */
+typedef struct sys·TerminalIO sys·TerminalIO;
+
+struct sys·TerminalIO
+{
+	uint  i,o,c,l; /* input,output,control,local flags */
+	uchar line;
+	uchar ctrl[32]; /* control chars */
+	uint  ispeed;   /* input speed */
+	uint  ospeed;   /* output speed */
+};
+
 #undef packed
diff --git a/sys/linux/src/sbrk.c b/sys/linux/src/sbrk.c
index 31af79b..96dcfe5 100644
--- a/sys/linux/src/sbrk.c
+++ b/sys/linux/src/sbrk.c
@@ -3,4 +3,5 @@
 int
 sys·sbrk(intptr inc, void *ret)
 {
+    return 0;
 }